I've often wondered what things we have in style guides which make it difficult for visually impaired programmers. I would like to know how to make my code easier for you to read and write. Please help me to improve my code for you.
I used a screen reader for a few years due to sight issues, these days I use a screen again with magnification. When you work without a screen you end up having to build up a mental model of the code, which you keep inside your head. When you navigate the code, you are doing it mentally, inside this cathedral you maintain in your mind.
So given that, the main challenge for me was code navigation. I used Visual Studio at the time and it allowed me to jump to method definitions, call references, jump to the start/end of a method etc. So the worst thing was long methods as 1) I had no efficient way of navigating them except to read each line 2) it was hard to keep track of all the things the method did. Breaking up code into smaller pieces with good naming of each method helped speed up my understanding and navigation of the code a lot. It also simplified the mental model in my mind.
As a person who can visually see, I want to emphasize that these goals: short methods (max 40 LOCs) and speaking names for all code entities are equally important to me. I want to spend as few time as possible reading the code. I want to spend most time on modifying and transforming the code. I do so by building up a mental model which I can change freely before typing the changes down. Sometimes it helps to write down the ideas to see how they "look like", however everything you say applies equally well to me as a non-blind programmer.
Another important trait of easy to read code is the rule of "Big picture" first. I.e. if you have a `main()` method you will find it first in my files, only then followed by sub methods which are called by main(). Same holds for types: first comes the class and then it's followed by any type which might be required for a class attribute. So, when opening a file you immediately get the big picture and depending on the granularity you want to build for your mental model you can continue reading by scrolling down. When the model is good enough, you can skip the rest of the file.
I find this pattern to the contrary of how others design their files. There are people who list all details and sub methods first before telling me only further down the road how these details are put together. This forces me to read a lot of code to build a blown up mental model which might not be necessary for the current task at hand.
I've just written a little parser I OCaml, and the file goes like this:
Module declarations ( 3 lines)
Parser type declaration ( 1 line )
Implementation details you don't care about (47 lines)
Actual grammar (20 lines)
In that order. In Haskell, I would probably have put the grammar at the top of the file, so you can get the big picture right away. But the language reads stuff from top to bottom, so I have to put the big picture at the bottom.
An alternative would be separate the details from the grammar, but then I would expose those implementation details in an interface, while in fact the rest of the program is only interested in one function that parses everything.
Or, you could write from bottom to top. It's OCaml, so you know the big picture cannot be at the top. Now a case could be made for a language that reads toplevel statements from bottom to top…
To be fair, C is kind of like that, too. You could move the declarations of static functions to the top, but then you'd still have declarations that prevent you from getting to the real meat.
That and poor/nonexistent syntax for macros are about my only 2 serious gripes I have with OCaml. The third was missing multithreading, but IIIC this seems to kinda be workable now with lwt IIUC?
In my career I have found programmers generally fall into two camps:
- those that prefer high-level overviews first, then drill down to learn details later
- those that want to thoroughly understand each smaller building block first before dealing with bigger picture concerns
For example, I jump right into projects and skim the docs and start hacking stuff together without learning the nuts and bolts, whereas my cofounder likes to read the theory behind the library, then read the source code before even starting to write a single line that uses the library. Both approaches are valid, I've just found most people tend to strongly prefer one approach or the other, and it's helpful to identify what a person's preferred approach is when working with them.
> When you work without a screen you end up having to build up a mental model of the code, which you keep inside your head. When you navigate the code, you are doing it mentally, inside this cathedral you maintain in your mind.
Interesting! I am not visually impaired (not beyond what can be fixed with reading glasses), but I have always worked like that with code.
To get some perspective on the difficulty of building this model, imagine you can see fine, but your screen can only display one word (token) at a time. You can navigate with arrow keys and a list of keyboard short-cuts.
This restriction applies to whether you are coding, browsing the web (on Stack Overflow), reading XML (shudder).
So the importance of a mental model is critical, because without maintaining context of where you are, you can get lost and spend too much time rediscovering your surroundings. The better your model the faster you can navigate and the less effort required in general.
I think you have nailed the reason why I work like that: I learned to program in the days of line editors. So it was quite like what you said, only not with a word at the time but a line at the time which is way too little context so you need something to offset that.
This might be a stupid question, but is there a kind of "modern" line editor, maybe with jump-to functionality, that would only show me one line of code at a time?
I wonder if programming like that would force an improvement in my code: kind of like programming through a keyhole, rather than the information overload of 20 documents open simultaneously.
Maybe an Emacs mode with Intellisense, that only showed a line at a time, with syntax highlighting?
I wish a good blind programmer would write a book. I really think there are great gains to be made in programming, when we find ways to optimize the way we build and maintain our mental models of an application. I suspect blind programmers have some good insights to share.
A visually impaired software engineer at Yelp recently published a blog post titled, "A Guide to Software Engineering for the Visually Impaired"[1]. He also gave talks at PyOhio[2] and North Bay Python[3].
There has been a very interesting discussion, that is not 100% equal but where you can get comments about similar problems, including some from blind programmer. I hope they may be helpful.
This thread touched off an idea for a journalism piece that I think could work in something like The Atlantic.
I bounced it off of my new writing partner[0] and she's interested in collaborating on it. If you're in software and you know a blind person that's working on something difficult, high impact, or otherwise noteworthy please reach out to me. It would be great to chat with them. The more that society appreciates the blind and understands their day-to-day the better it will be accommodated.
[0] She's the former Sr Editor of The Walrus (essentially Canada's The New Yorker), so she's quite good.
If you're using a smart phone, and it works, you're using code blind people wrote. I worked with many very excellent software engineers back in my days of writing network infrastructure code. Some just happened to be blind.
Code is plain text, and development environments can be navigated with keyboards. If I were to suggest that a blind developer needed my help, I would have something thrown at me. Luckily, the aim is not so good.
Sorry for highjacking your thread, but since the subject of reverse engineering is very close, writing it here. Radare2 project is famous to be blind users friendly, but we want the same thing for Cutter also [1]. If you know how to improve radare2 expierence too, don't hesitate to open an issue on our GitHub [2].
To pile on here on a (vaugely) related tangent, Common Voice (from Mozilla) needs our help to build a public speech corpus for training speech recognition software and Text to Speech: https://voice.mozilla.org/
Mozilla is currently hard at work on DeepSpeech for transcription and Text to Speech, which could be huge for accessibility. I hope it continues to improve :P
One very specific thing I remember from discussions I had with a blind programmer was to use of multi-line comments (/* /) in favour of line-comments (//), especially for comments that do span multiple lines.
That helps a lot because with a screen reader “slash star <comment text> star slash” is significantly more listenable to when compared to “slash slash <one line> slash slash <another line> slash slash <third line>…”
Surprisingly this is the only thing I cannot seem to find around my IRC logs… Digging through the logs other things that were called out to make comprehension harder for blind people are:
* Unicode identifiers;
* Boilerplate you cannot easily skip past without losing context (common in e.g. Java);
* Typos (esp. if done on purpose, inconsistently);
All this comes from their preferred interface being a screen reader which, I believe, is true for most blind programmers.
Screen readers should be made more context aware. The IDE knows what's a comment, the screen reader should know that as well: "comment <comment text> end comment" or something.
This may be even more important for the rest of the code. Who cares about the parentheses after the `if` keyword? No one, they're just there to delimit the condition. Likewise the curly braces, they just delimit a sub-block. Their absence should not stop the screen reader from spotting the end of the `if` block. They should say "end if" regardless. Same goes for Python.
Structural editors have mostly failed, but maybe some specialised version could be more useful to blind people?
Some people use the archaic spelling "shew" but only the senses "to prove or demonstrate". Or again in mathematics "rng" to mean a ring that does not necessarily have an identity. Or "iff" to mean "if and only if". These would look like inconsistent typos to nonmathematicians.
Or "referer" in HTTP because that's what the standard uses. Or "creat" when discussing the UNIX system call or a function with the same purpose on another platform.
I’ve also worked on codebases where the first developer misspelled a function’s name and everyone else just kept using it instead of fixing it. When I see stuff like that, I admit that I judge them probably harsher than they deserve. Sloppy!
I am not blind but I have shitty sight and I wish web browsers do the same thing they are doing now with http sites an deny access to web pages with light grey text over nuclear white background.
I do not think you need to deny access (although I think that if the webpage doesn't need colours, it shouldn't set any at all, instead using the user's preferences), but (as defanor mentioned) you can apply CSS (although it doesn't have to be global; I generally apply user CSS individually instead, since each webpage needs a different CSS to be fixed; usually webpages that don't already have CSS don't need any CSS to fix them, I find, though)
One useful thing seems to be using an auto code formatter and requiring the code is always autoformatted. Manually ensuring indentation is right is very awkward, just running clang-format, or whatever, is simple.
I think this is my favorite trend in programming languages. It seemed controversial when Go shipped with a canonical auto-formatter, but now I consider it table stakes.
I think, as many seem to be picking up, that tooling is critical for blind programmers and is secondary to how the language is designed. No matter how the language is represented in text, it can be made accessible with the right tooling. Often, however, this doesn't exist. This is why Python is quite polarizing for blind programmers, some love its simplicity and readability and others find the whitespace trips them up. But I think this is a function of what tools blind programmers land on to use Python...and probably also how much residual vision the programmer has. Remember that only 10% or so of blind people are totally blind.
I think the coding is never easier for all. One of the most dangerous things I’ve seen happen to people who are just starting to code is being told that it’s easy. But when you done any task and project goal day by day you sharp your expertise.
I often wonder how blind people deal with PDF's in general, and scientific articles (sometimes scanned, or pixel rendered) in specific? Or are they effectively locked out from reading scientific papers?
So given that, the main challenge for me was code navigation. I used Visual Studio at the time and it allowed me to jump to method definitions, call references, jump to the start/end of a method etc. So the worst thing was long methods as 1) I had no efficient way of navigating them except to read each line 2) it was hard to keep track of all the things the method did. Breaking up code into smaller pieces with good naming of each method helped speed up my understanding and navigation of the code a lot. It also simplified the mental model in my mind.