<p>The discussion whether using indentation for code blocks is better or worse than using braces is an old one, but I don't want to rehash that discussion here (for reference, there was a fairly recent <a href="https://langdev.stackexchange.com/questions/33/what-are-the-drawbacks-of-using-indentation-for-code-blocks">question about the drawbacks of indentation</a> that summarizes some of the arguments).</p>
<p>Instead, I'd like to know if there has ever been a systematic study on which of the two design choices is easier to learn for absolute programming beginners. I'm thinking of something like a study in which one group of participants (without any prior experience in programming) was taught a proto-language that featured code-block indentation. The other group of participants was taught a syntactically equivalent proto-language with the only difference that this language and the teaching material used braces instead of indentation. You could then compare the success of these participants in performing little coding tasks.</p>
<p>I've searched for such a study, but was unsuccessful. Has any such study ever been published?</p>

<syntax><design-choice-comparison><indentation>
Studies on learnability of braces vs. indentation for code blocks for beginners?
CC BY-SA 4.0
2023-11-28T09:02:00.287Z
I will come back to this tomorrow, but I believe the answer is no, there hasn't been any systematic pedagogical study of that specific feature in isolation (in all honesty, it's likely infeasible to do so in any reliable way for one individual element). There is evidence that use of indentation *in addition* to other structure is helpful, although a little more mixed than one might expect; there are also comparative studies on structured editors where "indentation" is innate compared with non-structured editors for the same language, but those have significant confounds.
Michael Homer
CC BY-SA 4.0
2023-11-28T16:55:15.573Z
Just to clarify, when you say "braces", do you mean "braces with their content indented" (as in C-like languages), or "braces but no indentation"?
Pablo H
CC BY-SA 4.0
2023-11-28T17:38:46.763Z
@PabloH I believe it is safe to assume that the OP meant braces with indented content, otherwise it wouldn't have been too much of a competition versus plain indentation.
Hg0428
CC BY-SA 4.0
2023-11-28T17:38:48.067Z
@PabloH: Given the apparent scarcity of research on this topic, I'd be happy with either of the two.
Schmuddi
CC BY-SA 4.0
2023-11-28T17:49:56.853Z
@Hg0428 Exactly. But then the question is "having always indentation, braces or no braces?".
Pablo H
CC BY-SA 4.0
2023-11-28T18:08:09.250Z
I don't think the study you propose would necessarily be fair, because even in languages with braces, beginners are (appropriately!) taught to *also* use indentation to denote blocks. And it seems obvious enough that braces without indentation would be terrible. So really it's about whether the small difficulty of writing braces is worth the small benefit of your code working if you get the braces right but the indentation wrong. I'd argue the latter is *not* a benefit, because if a beginner has indentation not matching their braces, the program likely doesn't do what they want it to ayway.
kaya3
CC BY-SA 4.0
2023-11-28T21:07:13.317Z
I don't personally know of any studies, but I will remark that Python's indentation-but-no-braces style comes from Guido van Rossum's academic work on the [ABC programming language](https://en.wikipedia.org/wiki/ABC_%28programming_language%29) for beginners at the Centrum Wiskunde & Informatica -- there may be a publication from CWI looking at indentation in conjunction with ABC.
R.M.
CC BY-SA 4.0
2023-11-29T18:16:03.583Z
A proper study is likely to be difficult, because doing it right would require either that you only look at complete beginners who are still monoglots (increasingly rare with the shift towards web development as the ‘anyone can do it’ example for programming), or that you somehow find programmers who have only ever used one style (easy for curly-brace languages, and possibly for Lisp derivatives, not so much for off-side languages or keyword-block languages, because they’ve probably dealt with JSON).
Austin Hemmelgarn
CC BY-SA 4.0
2023-12-02T10:23:28.010Z
It's a data point of one, but I once taught Python to an adult with no prior programming experience, and indentation was a constant source of confusion. They found it hard to understand that some statements are inside a for loop and some outside it, and I think the fact that this is determined by indentation made it much more mysterious. I ended up with the impression that *understanding what a for loop is* and *correctly indenting a for loop* are separate skills, and if someone's struggling with one I don't think it helps to make them learn the other at the same time.
N. Virgo
<p>As far as I know, no such study exists. I haven't been able to find one. But, to attempt to help you as much as possible, I will tell you what I have learned on the subject.</p>
<p>In my experience teaching and helping beginners, indentation provides a more readable and intuitive interface for the beginners, yet many will begin to prefer braces once they get used to coding. Both have an initial learning curve, but it is initially a little higher with the braces, because the new coder has to get used to the idea of using braces to group things. Indentation is a little easier in this respect, because everyone is already used to grouping things with indentation. Indentation is everywhere, from paragraphs to quotation. It's not as much to get used to, initially.</p>
<p>Overall, I don't think there is one choice that is definitively better for beginners. To make a study on the subject would probably be impractical because there would likely be more difference in how well the two groups learned than the difference actually made by the type of code block.</p>

CC BY-SA 4.0
2023-11-28T16:41:57.843Z
2023-11-28T16:41:57.843Z
Hg0428
CC BY-SA 4.0
2023-11-28T17:32:39.280Z
Could I add to this by saying that GNU brace placement is generally far easier for students to get used to than K&R
ScottishTapWater
CC BY-SA 4.0
2023-11-28T17:48:28.810Z
^^ emacs style, not GNU style
ScottishTapWater
<p>I don't believe that there is any systematic pedagogical study on this feature specifically. Studies of actual <em>learning</em> are complex, time-consuming, and expensive, and I don't think any has been done (or likely would be) on that difference in isolation. The totality of human-factors studies comparing language design decisions likely numbers in the dozens (depending on your counting criteria, somewhere between 35 and 137 existed in 2012, per <a href="https://jyx.jyu.fi/handle/123456789/47698" rel="noreferrer">Antti-Juhani Kaijanaho's PhD thesis</a>).</p>
<p>However, there has been work on program comprehension and reproduction under different indentation and delimiting modalities, and on learning performance in different languages and editing environments. These are more mixed on indentation than you might expect: it's widely accepted that correctly indenting to match structure is helpful, but in fact empirical studies often show limited or no impact in practice. My high-level summary of the state of the art for block structure <em>for novice programmers</em> is that</p>
<ol>
<li>indentation is valuable, but they don't use it unless enforced; and</li>
<li>keyword-based systems are more effective than symbol-based systems;</li>
<li>redundancy enables enhanced errors and thus improves effectiveness.</li>
</ol>
<p>None of these are strongly results. It is not clear that the benefits of keywords survive to expert programmers or with editor support for delimiting symbols. There has also been a lot of work with Lisps for novices, which are all delimiter and no indentation. It is likely that the ideal system for learners at this stage will both use delimiters <em>and</em> enforce that indentation is consistent with those delimiters (and this is the approach that recent novice-targeting languages like Pyret and Grace have taken, albeit without specific evidentiary basis).</p>
<p>I will point to some specific studies below, although they are not as strongly-grounded as I would like. None of the indentation-focused ones are comparing to <em>brace</em>-based languages or to semantically-significant indentation, though there are some suggestive pointers. I think the most relevant result is from the Quorum studies, suggesting that braces in particular perform poorly.</p>
<hr />
<ul>
<li><a href="https://doi.org/10.1016/S0020-7373(84)80068-1" rel="noreferrer">The effect of indentation on program comprehension</a>, Thomas E. Kesler, Randy B. Uram, Ferial Magareh-Abed, Ann Fritzche, Carl Amport, H.E. Dunsmore, 1982.</li>
<li><a href="https://doi.org/10.1145/182.358437" rel="noreferrer">Program Indentation and Comprehensibility</a>, Richard J. Miara, Joyce A. Musselman, Juan A. Navarro, Ben Shneiderman, 1983.</li>
</ul>
<p>These studies looked at Pascal (keyword blocks, but all <code>begin</code>-<code>end</code>) programs with different indentation levels. The findings were that moderate indentation was beneficial for novice comprehension over both no indentation and greater levels of indentation. These are not brace-based programs and participants were already learning or programming in Pascal; the effect size is also surprisingly large for the difference between four- and six-space indents. There were a number of indentation studies around this time, with generally similar results, but not with novices in pure indentation-structured languages.</p>
<ul>
<li><a href="https://doi.org/10.1109/ICPC.2019.00033" rel="noreferrer">Indentation: Simply a Matter of Style or Support for Program Comprehension?</a>, Jennifer Bauer, Janet Siegmund, Norman Peitek, Johannes C. Hofmeister, Sven Appel, 2019.</li>
</ul>
<p>This was a partial replication of the previous study, using curly-brace Java instead of Pascal, with students, and eight instead of six spaces. They found <em>no impact from indentation at all</em> on any of their measures: even zero indentation gave similar performance.</p>
<ul>
<li><a href="https://doi.org/10.1016/S0020-7373(84)80065-6" rel="noreferrer">Conditional statements and program coding: an experimental evaluation</a>, Iris Vessey, Ron Weber, 1984.</li>
</ul>
<p>This compares an IF-GOTO-based structure with (non-semantic) indentation with a variety of block-structured systems, using genuine novices in a controlled trial. The closest to braces is the <code>begin</code>-<code>end</code> variant of the language, and the programs in the GOTO version <em>looked like</em> an off-side-rule language, but the line labels were semantically significant; the other variants used <code>IF</code>-<code>OTHERWISE</code> and <code>IF x</code>-<code>NOT x</code>. The methodology had participants review a short tutorial on the language condition in use, and then write programs to implement a specific condition table. Indentation helped for all but one of their variants, but the version with distinguished start and end markers for <em>each</em> conditional performed worse. Participants had a lot of difficulty getting the indentation right in the GOTO case, but when they did their programs were no worse than others.</p>
<p>That's about it as far as studies that isolated indentation as a factor, and none of them are really approaching your question directly. We can take some hints that indentation is probably useful and can be sufficient, but that delimited block structure can <em>also</em> be sufficient on its own.</p>
<ul>
<li><a href="https://doi.org/10.1145/2534973" rel="noreferrer">An Empirical Investigation into Programming Language Syntax</a>, Andreas Stefik and Susanna Siebert, 2013.</li>
</ul>
<p>This is part of the <a href="https://quorumlanguage.com/" rel="noreferrer">Quorum</a> project, a focal point for modern empirical language design for novices (and the source of the famous &quot;randomly-generated language more usable than Perl&quot; claim). Most of this relates to keyword choices and indentation was not studied specifically, but of relevance here was a finding that <strong>block constructions that <em>did not</em> use braces had better performance metrics than those that did</strong>, although that subgroup included both the indentation-only Python and the <em>keyword</em>-<code>end</code> Quorum and Ruby.</p>
<p>The best performers, very close together, were Ruby and then Python, with Perl and Java not statistically significantly different from Randomo, which was Quorum with braces and random ASCII keywords. Some issues writing the <code>end</code> keyword correctly were reported, but Quorum still uses that keyword today, so it wasn't found to be that bad of an issue.</p>
<p>In all cases, &quot;correct&quot; indentation was presented in the learning material, but I don't believe it was required in what was produced except for Python. Indentation is encouraged <em>but not required</em> in Quorum, I think to reduce unnecessary errors during editing. Follow-up work on Quorum has reinforced these results for it.</p>
<p>There are various other studies on teaching language pairs that I'm sure you've seen, but they don't generally get to this level of granularity and there are significant confounds for teasing out anything like this.</p>
<hr />
<p>To conclude here, I don't believe such a study exists. I am confident that there isn't one prior to 2014, and I am not aware of and couldn't find any since either. I am sceptical that it would be worthwhile to run one for novices, because the value of that one factor is unlikely to be worth the substantial cost of running a genuine learning study, though a comprehension study is plausible.</p>
<p>The general direction of the literature is that <em>braces</em> are not highly effective for novices, although lexically substituting an explicit end-of-block delimiter <em>word</em> for <code>}</code> seems to do better, and omitting any opening delimiter has some support too. Semantic indentation isn't supported one way or the other by this, but there is some evidence that matching end delimiters presents a difficulty, which is a matter that doesn't arise for semantic indentation. I don't think there is sufficient evidence to draw a conclusion one way or another.</p>

CC BY-SA 4.0
2023-11-29T02:11:29.080Z
2023-11-29T02:11:29.080Z
Michael Homer
CC BY-SA 4.0
2023-11-29T17:03:13.630Z
How did you find all this???? Google and Bing could find nothing on the subject. Great answer by the way, well formatted and very useful.
Hg0428
CC BY-SA 4.0
2023-11-29T17:11:03.217Z
@Hg0428 I looked in the ACM DL in the first instance, but I’d seen most of them before so I knew they existed. Some backward/forwards snowballing from one I’d already found, but there really isn’t very much to find, I think.
Michael Homer
CC BY-SA 4.0
2023-11-29T21:12:43.640Z
This is an awesome answer – much more thorough than anything I'd imagined. Thanks a lot!
Schmuddi
CC BY-SA 4.0
2023-11-30T14:09:13.453Z
In the lisp/scheme cultures that I’m aware of, poor indentation is a faux-pas. That is, it is encouraged to aid comprehension but not required to compile (which seems similar to what you say about Quorum).
D. Ben Knoble
CC BY-SA 4.0
2023-12-02T03:06:32.687Z
Fortran-style end-of-block delimiting seems to be an especially worthwhile point in the design space, given your numbered summary points. For anyone unfamiliar, the only required syntactic element is `end`, but it can optionally be elaborated in agreement with the thing being ended. `if`/`end if`, `subroutine foo`/`end subroutine`/`end subroutine foo`. That might be nice for Quorum to try if they haven't already
Phil Miller
# Studies on learnability of braces vs. indentation for code blocks for beginners?
Posted by: username_0 on 2023-11-28
The discussion whether using indentation for code blocks is better or worse than using braces is an old one, but I don't want to rehash that discussion here (for reference, there was a fairly recent [question about the drawbacks of indentation](https://langdev.stackexchange.com/questions/33/what-are-the-drawbacks-of-using-indentation-for-code-blocks) that summarizes some of the arguments).

Instead, I'd like to know if there has ever been a systematic study on which of the two design choices is easier to learn for absolute programming beginners. I'm thinking of something like a study in which one group of participants (without any prior experience in programming) was taught a proto-language that featured code-block indentation. The other group of participants was taught a syntactically equivalent proto-language with the only difference that this language and the teaching material used braces instead of indentation. You could then compare the success of these participants in performing little coding tasks.

I've searched for such a study, but was unsuccessful. Has any such study ever been published?
**Tags:** syntax design-choice-comparison indentation
> **Comments:**
> **username_1**: I will come back to this tomorrow, but I believe the answer is no, there hasn't been any systematic pedagogical study of that specific feature in isolation (in all honesty, it's likely infeasible to do so in any reliable way for one individual element). There is evidence that use of indentation *in addition* to other structure is helpful, although a little more mixed than one might expect; there are also comparative studies on structured editors where "indentation" is innate compared with non-structured editors for the same language, but those have significant confounds.  
> **username_2**: Just to clarify, when you say "braces", do you mean "braces with their content indented" (as in C-like languages), or "braces but no indentation"?  
> **username_3**: @PabloH I believe it is safe to assume that the OP meant braces with indented content, otherwise it wouldn't have been too much of a competition versus plain indentation.  
> **username_0**: @PabloH: Given the apparent scarcity of research on this topic, I'd be happy with either of the two.  
> **username_2**: @Hg0428 Exactly. But then the question is "having always indentation, braces or no braces?".  
> **username_4**: I don't think the study you propose would necessarily be fair, because even in languages with braces, beginners are (appropriately!) taught to *also* use indentation to denote blocks. And it seems obvious enough that braces without indentation would be terrible. So really it's about whether the small difficulty of writing braces is worth the small benefit of your code working if you get the braces right but the indentation wrong. I'd argue the latter is *not* a benefit, because if a beginner has indentation not matching their braces, the program likely doesn't do what they want it to ayway.  
> **username_5**: I don't personally know of any studies, but I will remark that Python's indentation-but-no-braces style comes from Guido van Rossum's academic work on the [ABC programming language](https://en.wikipedia.org/wiki/ABC_%28programming_language%29) for beginners at the Centrum Wiskunde & Informatica -- there may be a publication from CWI looking at indentation in conjunction with ABC.  
> **username_6**: A proper study is likely to be difficult, because doing it right would require either that you only look at complete beginners who are still monoglots (increasingly rare with the shift towards web development as the ‘anyone can do it’ example for programming), or that you somehow find programmers who have only ever used one style (easy for curly-brace languages, and possibly for Lisp derivatives, not so much for off-side languages or keyword-block languages, because they’ve probably dealt with JSON).  
> **username_7**: It's a data point of one, but I once taught Python to an adult with no prior programming experience, and indentation was a constant source of confusion. They found it hard to understand that some statements are inside a for loop and some outside it, and I think the fact that this is determined by indentation made it much more mysterious. I ended up with the impression that *understanding what a for loop is* and *correctly indenting a for loop* are separate skills, and if someone's struggling with one I don't think it helps to make them learn the other at the same time.  
---
## 2 answers
### Answer by username_1 on 2023-11-29. Score: 24 | Accepted answer
I don't believe that there is any systematic pedagogical study on this feature specifically. Studies of actual *learning* are complex, time-consuming, and expensive, and I don't think any has been done (or likely would be) on that difference in isolation. The totality of human-factors studies comparing language design decisions likely numbers in the dozens (depending on your counting criteria, somewhere between 35 and 137 existed in 2012, per [Antti-Juhani Kaijanaho's PhD thesis](https://jyx.jyu.fi/handle/123456789/47698)).

However, there has been work on program comprehension and reproduction under different indentation and delimiting modalities, and on learning performance in different languages and editing environments. These are more mixed on indentation than you might expect: it's widely accepted that correctly indenting to match structure is helpful, but in fact empirical studies often show limited or no impact in practice. My high-level summary of the state of the art for block structure *for novice programmers* is that

1. indentation is valuable, but they don't use it unless enforced; and
2. keyword-based systems are more effective than symbol-based systems;
3. redundancy enables enhanced errors and thus improves effectiveness.

None of these are strongly results. It is not clear that the benefits of keywords survive to expert programmers or with editor support for delimiting symbols. There has also been a lot of work with Lisps for novices, which are all delimiter and no indentation. It is likely that the ideal system for learners at this stage will both use delimiters *and* enforce that indentation is consistent with those delimiters (and this is the approach that recent novice-targeting languages like Pyret and Grace have taken, albeit without specific evidentiary basis).

I will point to some specific studies below, although they are not as strongly-grounded as I would like. None of the indentation-focused ones are comparing to *brace*-based languages or to semantically-significant indentation, though there are some suggestive pointers. I think the most relevant result is from the Quorum studies, suggesting that braces in particular perform poorly.

---

* [The effect of indentation on program comprehension](https://doi.org/10.1016/S0020-7373(84)80068-1), Thomas E. Kesler, Randy B. Uram, Ferial Magareh-Abed, Ann Fritzche, Carl Amport, H.E. Dunsmore, 1982.
* [Program Indentation and Comprehensibility](https://doi.org/10.1145/182.358437), Richard J. Miara, Joyce A. Musselman, Juan A. Navarro, Ben Shneiderman, 1983.

These studies looked at Pascal (keyword blocks, but all `begin`-`end`) programs with different indentation levels. The findings were that moderate indentation was beneficial for novice comprehension over both no indentation and greater levels of indentation. These are not brace-based programs and participants were already learning or programming in Pascal; the effect size is also surprisingly large for the difference between four- and six-space indents. There were a number of indentation studies around this time, with generally similar results, but not with novices in pure indentation-structured languages.

* [Indentation: Simply a Matter of Style or Support for Program Comprehension?](https://doi.org/10.1109/ICPC.2019.00033), Jennifer Bauer, Janet Siegmund, Norman Peitek, Johannes C. Hofmeister, Sven Appel, 2019.

This was a partial replication of the previous study, using curly-brace Java instead of Pascal, with students, and eight instead of six spaces. They found *no impact from indentation at all* on any of their measures: even zero indentation gave similar performance.

* [Conditional statements and program coding: an experimental evaluation](https://doi.org/10.1016/S0020-7373(84)80065-6), Iris Vessey, Ron Weber, 1984.

This compares an IF-GOTO-based structure with (non-semantic) indentation with a variety of block-structured systems, using genuine novices in a controlled trial. The closest to braces is the `begin`-`end` variant of the language, and the programs in the GOTO version *looked like* an off-side-rule language, but the line labels were semantically significant; the other variants used `IF`-`OTHERWISE` and `IF x`-`NOT x`. The methodology had participants review a short tutorial on the language condition in use, and then write programs to implement a specific condition table. Indentation helped for all but one of their variants, but the version with distinguished start and end markers for *each* conditional performed worse. Participants had a lot of difficulty getting the indentation right in the GOTO case, but when they did their programs were no worse than others.

That's about it as far as studies that isolated indentation as a factor, and none of them are really approaching your question directly. We can take some hints that indentation is probably useful and can be sufficient, but that delimited block structure can *also* be sufficient on its own.

* [An Empirical Investigation into Programming Language Syntax](https://doi.org/10.1145/2534973), Andreas Stefik and Susanna Siebert, 2013.

This is part of the [Quorum](https://quorumlanguage.com/) project, a focal point for modern empirical language design for novices (and the source of the famous "randomly-generated language more usable than Perl" claim). Most of this relates to keyword choices and indentation was not studied specifically, but of relevance here was a finding that **block constructions that *did not* use braces had better performance metrics than those that did**, although that subgroup included both the indentation-only Python and the *keyword*-`end` Quorum and Ruby.

The best performers, very close together, were Ruby and then Python, with Perl and Java not statistically significantly different from Randomo, which was Quorum with braces and random ASCII keywords. Some issues writing the `end` keyword correctly were reported, but Quorum still uses that keyword today, so it wasn't found to be that bad of an issue.

In all cases, "correct" indentation was presented in the learning material, but I don't believe it was required in what was produced except for Python. Indentation is encouraged *but not required* in Quorum, I think to reduce unnecessary errors during editing. Follow-up work on Quorum has reinforced these results for it.

There are various other studies on teaching language pairs that I'm sure you've seen, but they don't generally get to this level of granularity and there are significant confounds for teasing out anything like this.

---

To conclude here, I don't believe such a study exists. I am confident that there isn't one prior to 2014, and I am not aware of and couldn't find any since either. I am sceptical that it would be worthwhile to run one for novices, because the value of that one factor is unlikely to be worth the substantial cost of running a genuine learning study, though a comprehension study is plausible.

The general direction of the literature is that *braces* are not highly effective for novices, although lexically substituting an explicit end-of-block delimiter *word* for `}` seems to do better, and omitting any opening delimiter has some support too. Semantic indentation isn't supported one way or the other by this, but there is some evidence that matching end delimiters presents a difficulty, which is a matter that doesn't arise for semantic indentation. I don't think there is sufficient evidence to draw a conclusion one way or another.
> **Comments:**
> **username_3** (2023-11-29): How did you find all this???? Google and Bing could find nothing on the subject. Great answer by the way, well formatted and very useful.  
> **username_1** (2023-11-29): @Hg0428 I looked in the ACM DL in the first instance, but I’d seen most of them before so I knew they existed. Some backward/forwards snowballing from one I’d already found, but there really isn’t very much to find, I think.  
> **username_0** (2023-11-29): This is an awesome answer – much more thorough than anything I'd imagined. Thanks a lot!  
> **username_9** (2023-11-30): In the lisp/scheme cultures that I’m aware of, poor indentation is a faux-pas. That is, it is encouraged to aid comprehension but not required to compile (which seems similar to what you say about Quorum).  
> **username_10** (2023-12-02): Fortran-style end-of-block delimiting seems to be an especially worthwhile point in the design space, given your numbered summary points. For anyone unfamiliar, the only required syntactic element is `end`, but it can optionally be elaborated in agreement with the thing being ended. `if`/`end if`, `subroutine foo`/`end subroutine`/`end subroutine foo`. That might be nice for Quorum to try if they haven't already  
---
### Answer by username_3 on 2023-11-28. Score: 2
As far as I know, no such study exists. I haven't been able to find one. But, to attempt to help you as much as possible, I will tell you what I have learned on the subject.

In my experience teaching and helping beginners, indentation provides a more readable and intuitive interface for the beginners, yet many will begin to prefer braces once they get used to coding. Both have an initial learning curve, but it is initially a little higher with the braces, because the new coder has to get used to the idea of using braces to group things. Indentation is a little easier in this respect, because everyone is already used to grouping things with indentation. Indentation is everywhere, from paragraphs to quotation. It's not as much to get used to, initially.

Overall, I don't think there is one choice that is definitively better for beginners. To make a study on the subject would probably be impractical because there would likely be more difference in how well the two groups learned than the difference actually made by the type of code block.
> **Comments:**
> **username_8** (2023-11-28): Could I add to this by saying that GNU brace placement is generally far easier for students to get used to than K&R  
> **username_8** (2023-11-28): ^^ emacs style, not GNU style  
---
