Gmail.com was down - <AUTHOR> https://mail.google.com/ <comment><USER4> A tweet by The Onion:

[In Focus] Google Shuts Down Gmail To Show Its Immense Power <http://onion.com/UxyLs8>

<comment><USER5> Gmail returns with G+ as your inbox.

<comment><USER6> ಠ_ಠ

<comment><USER7> And suddenly I'm on Reddit.

</comment></comment></comment></comment><comment><USER8> Is this affecting Chrome as well? Looks like it might be a bigger problem. It just crashed for three guys in our office within a few seconds of each other.

Edit: Nobody was using Gmail at any point.

<comment><USER9> Chromium crash on Arch Linux with this message: <http://pastebin.com/f9JMsPzT>

        terminate called after throwing an instance of 'std::out_of_range'
          what():  bitset::set
        [1]    4934 abort (core dumped)  chromium

singing out of sync for now..

Edit: no crashes since I signed out of sync

Edit2: found a more complete stack trace by somebody else: <https://gist.github.com/4251938>

Bug Report: <http://code.google.com/p/chromium/issues/detail?id=165171>

<comment><USER10> Wow, a lot of people use Chromium over Chrome because of "omg botnet" - <USER2> wonder why Google downtime would cause vanilla Chromium to crash?

<comment><USER11> I thought Chromium still had all the google tie-in issue. If I remember correctly what they pulled out was license encumbered features like font rendering. I know there were forks like iron that pull out the privacy features.

</comment></comment></comment></comment><comment><USER12> Probably not the time to rub people's face in it, but I host my own mail server because of crap like this.

Thread from the other day:

<http://news.ycombinator.com/item?id=4886236>

<comment><USER13> Meh, I've had my Gmail for a little over 6 years now. This is the first time I ever remember having this problem. (My Gmail is back up now, by the way.) I'll take this frequency over the effort it takes to maintain my own mail server any day.

<comment><USER14> What effort? After setup, it just works.

</comment></comment></comment><comment><USER15> I've been on it for the past hour without a problem.

It must be server/account specific.

<comment><USER16> This literally went down about 45 seconds ago for me. Check again?

<comment><USER15> Got an email 5 minutes ago, just sent one to another gmail account a minute ago and just got a reply.

</comment></comment></comment><comment><USER17> I love google products (and I'm not worried about my email for a second), but their explanation is really bad:

"The problem with Google Mail should be resolved. We apologize for the inconvenience and thank you for your patience and continued support. Please rest assured that system reliability is a top priority at Google, and we are making continuous improvements to make our systems better."

It sounds like something an airline might say after bumping you to another flight!

[http://www.google.com/appsstatus#hl=en&v=issue&ts=13...](http://www.google.com/appsstatus#hl=en&v=issue&ts=1355212799000&iid=c4cb68ce9a417fa4832a731c7f71a9f0)

EDIT: Thanks @mpeg for pointing out that this is a different outage. Still yucky copy though.

<comment><USER18> Today's outage: [http://www.google.com/appsstatus#hl=en&v=issue&ts=13...](http://www.google.com/appsstatus#hl=en&v=issue&ts=1355201999000&iid=4abb2f6c40f6bd39677195b9a60ad77d)

So far it only says "We're investigating reports of an issue with Google Mail. We will provide more information shortly."

</comment></comment><comment><USER19> [http://www.google.com/appsstatus#hl=en&v=status&ts=1...](http://www.google.com/appsstatus#hl=en&v=status&ts=1355158213127)

Still no update

</comment><comment><USER20> I really hate when the browser crash in the middle of a

</comment><comment><USER21> _Error 502 (Server Error)!!1_

Is the 1 intentional?

<comment><USER22> Yeah, it's a common internet meme. Often you will see the word 'one' in there as well. e.g. !!!11!!!one!!

<comment><USER23> Yes. It reflects a certain "intensity" at the keyboard which may involve the shift key finger spasming.

</comment></comment></comment><comment><USER24> I wonder if this post has anything to do with it: [http://www.elezea.com/2012/12/google-calendar-lost-data- secu...](http://www.elezea.com/2012/12/google-calendar-lost-data-security- breach/)

<comment><USER25> I experienced a similar issue a couple of weeks ago when my synced chrome settings & bookmarks appeared on a co-worker's machine, a machine I've never signed in on. All his stuff was gone and replaced with an outdated version of mine...

</comment></comment><comment><USER26> There is now an post for this outage on the Google Apps Status Dashboard: [https://www.google.com/appsstatus#hl=en&v=issue&ts=1...](https://www.google.com/appsstatus#hl=en&v=issue&ts=1355183999000&iid=4abb2f6c40f6bd39677195b9a60ad77d)

"We're investigating reports of an issue with Google Mail. We will provide more information shortly."

</comment><comment><USER27> I have a new yellow notice on top of Gmail.

"Novità! Le app Gmail per dispositivi mobili sono appena state aggiornate su Google Play e nell'App Store di Apple. Ignora"

Translated: News! The mobile Gmail apps have just been updated on Google Play and App Store.

I wonder if this is related...

</comment><comment><USER28> Everything has downtime, folks. Everything.

</comment><comment><USER29> Ok, I would like to take this opportunity to ask something about HN.

What if, say a month later Gmail.com goes down again. Then, how do I submit another post to HN? I mean wouldn't I be redirected to this one?

<comment><USER30> To clarify what Cyranix said, it's possible to add a useless query string on the end of a URL in order to have HN fail to match a URL that's already been submitted. So say SocialMobileLocal.com goes down and someone submits a link:

      status.socialmobilelocal.com

When it goes down again a year later, you can submit:

      status.socialmobilelocal.com?foo=bar

<comment><USER29> Ah figured that myself. Now I can bring up old discussions again :)

</comment></comment></comment><comment><USER31> Oh that's what happened. This is a pretty unexpected oversight from a company that tests their software so extensively to have browsers crash because an email service/sync service is down.

</comment><comment><USER32> I'm having trouble too... the plain HTML version works though: <http://mail.google.com/mail/?ui=html>

</comment><comment><USER30> Seems to work in Firefox, for anyone who needs to urgently access their Gmail. Still down in Chrome for me (Error 502), though it's not crashing the browser.

<comment><USER33> Works for me with both Opera and Chrome. Even with chat. Either they fixed it or it's an issue only affecting part of userbase.

edit: I'm in Europe.

</comment></comment><comment><USER34> Its fixed for me now.

</comment><comment><USER35> Gmail is down and children are in the street weeping!

</comment><comment><USER36> Oddly enough I was on Gmail and Chrome kept crashing. Did all the usual stuff, cleared everything, restarted etc. Turns out, for me at least, the only time it crashes is when I go to Gmail.com.

I'd really love to investigate and find out why these two related products behave this way but honestly I'm way too lazy.

</comment><comment><USER37> No chrome crashs here (beta channel, sync enabled, germany, gmail tabs open), but Gmail was down too.

</comment><comment><USER38> First updates from Google's App Status Dashboard: [http://www.google.com/appsstatus#hl=en&v=issue&ts=13...](http://www.google.com/appsstatus#hl=en&v=issue&ts=1355201999000&iid=4abb2f6c40f6bd39677195b9a60ad77d)

</comment><comment><USER39> My Chrome did not crash, yet I am logged in with Sync. Instead of keeping Gmail in a Chrome tab, I use Fluid app to make Gmail into a "desktop" app. Seems to still be up. Others can use the same workaround by opening Google apps in Firefox and Safari.

</comment><comment><USER40> What is with the URL on this submission pointing to the URL any user of Gmail would use to access their account? Could the curators please change the submission URL to a source that shows reliable updated information?

</comment><comment><USER41> Down in France : [http://www.blog-nouvelles- technologies.fr/archives/21512/err...](http://www.blog-nouvelles- technologies.fr/archives/21512/error-502-gmail/)

</comment><comment><USER42> Anonymous is claiming credit. <http://www.chronicle.su/news/gmail-taken-down- by-anonymous/>

<comment><USER43> Nope, they actually denied it => "Anonymous immediately denied responsibility for the attack on Gmail before finding out that no one knew who perpetrated the attack, thus making it a legitimately"

</comment></comment><comment><USER44> Been on Chrome for about 50 minutes, was on Gmail at the beginning of that. The only thing that was crashed was the chat on Gmail. Have not had a single problem with Chrome.

</comment><comment><USER45> Gmail and all Google services are working for me using Chrome 24.0.1312.35 beta-m. I did have a 502 error for about 5 minutes, but it didn't crash the browser.

edit: typo

</comment><comment><USER46> Gmail for Business works from my imap client (postbox) but not from the web site. So I guess their web interface is down - not the backend mail engine.

<comment><USER47> IMAP works for me also with Thunderbird.

</comment></comment><comment><USER36> My Android phone sends and receives just fine. It seems like a web related issue, and Chrome is likely just relying on communications with the server

</comment><comment><USER48> I seem to still be able to send & receive mail via my sync on iPhone, and it seems Outlook Sync for Biz Apps is running fine. gmail.com only?

</comment><comment><USER49> Feedburner has also been sporadically returning temporary errors over the last hour. Looks like it's a google infrastructure problem.

</comment><comment><USER50> I can easily live with a few minutes of downtime for my mail, but they should fix Chrome and other platforms being dependant.

</comment><comment><USER51> I wonder if it's linked to that calendar bug?

</comment><comment><USER38> It's back up now. EDIT: went down again...

</comment><comment><USER52> Chrome crashed 3-4 times in a row trying to access Gmail. This was on Windows, and I was logged into Google Sync.

</comment><comment><USER38> Chrome just crashed on me for the first time. Gmail has been up and down a few times already the last 30 mins.

</comment><comment><USER53> The chrome crashing can be stopped if you disable Synching. Means disconnect your Google Account from Chrome

</comment><comment><USER54> I've been having luck with mutt. Looks like their POP / IMAP servers are running better than their webapp.

</comment><comment><USER55> On the plus side, the little broken robot drawing on their error page is cute. It is no Octocat, but hey.

</comment><comment><USER56> Haven't had a single problem, using both my Apps account and my Gmail account. Stockholm/Sweden, Firefox.

</comment><comment><USER57> ...and it's back up here now - must've only been down 10 minutes or so! (But Chrome just crashed again)

</comment><comment><USER58> Absolutely no problems with any Google services (Drive, Mail, Calendar, Search) for me (Northwest UK).

</comment><comment><USER59> Chrome crashed for the first time for me, when i tried refreshing the gmail.com page multiple times.

</comment><comment><USER60> I noticed that none of my comments in my google document saved after I recovered from the crash.

</comment><comment><USER61> I've just reloaded chrome twice as well as gmail and it's working fine here in Australia.

</comment><comment><USER62> Both my apps and personal account are down.

<edit> an both are back at 12:17pm EST</edit>

</comment><comment><USER63> It's working fine on Safari, albeit a little slowly. This seems to be Chrome specific.

</comment><comment><USER64> My Chrome crashed as well while trying to load gmail. But in firefox gmail is working.

</comment><comment><USER65> Google Plus is down for me now.

</comment><comment><USER66> Chrome crashing due to failed sync problems with google servers and gmail is down.

</comment><comment><USER67> The internet is awesome! This kind of collaborative trouble-shooting is epic!

</comment><comment><USER38> Awesome, on my birthday...guess people were sending me too many bday emails!

<comment><USER68> Aw, you too? Happy birthday! :-)

</comment></comment><comment><USER69> Play store is down for me too, crashed hard on my phone about 5 minutes ago

</comment><comment><USER70> Gmail is working for me in FireFox. In Chrome, it is still crashing.

</comment><comment><USER71> Chrome is crashing for me without even a gmail tab open. Curious...

</comment><comment><USER72> Gmail is down for me too.

</comment><comment><USER73> Strange, we got Youtube crashing chromes on all our Ubuntu machines

</comment><comment><USER74> I couldn't get into Google Docs either. Must be something going on.

</comment><comment><USER57> ...and it's back up here now - must've been down 10 minutes or so!

</comment><comment><USER24> a thread from earlier.<https://news.ycombinator.com/item?id=4898496>

Speculation that it is happening to many users.

</comment><comment><USER75> Google Now also appears to be having issues (at least for me).

</comment><comment><USER76> It's back up for me now

</comment><comment><USER77> Same problem here. All other Google services seem to be fine.

</comment><comment><USER78> Even my chrome is crashing, switched to firefox a while ago.

</comment><comment><USER79> Seems to be back up now. At least it's working for me.

</comment><comment><USER80> Chrome has crashed twice for me in the last 2 mins...

</comment><comment><USER81> It happens to the best of us :) is all I can think of

</comment><comment><USER82> Seems to be up again for me (connecting from Europe).

</comment><comment><USER83> Chrome Sync is crashing my Chrome every minute or so.

</comment><comment><USER84> Few more days for 21 December, Mayan calendar. :P

</comment><comment><USER85> ... and it's back.

</comment><comment><USER51> It's back up here

</comment><comment><USER86> Chrome didn't crash, but gmail is down for me

</comment><comment><USER87> Gmail work for me but chat isn't connecting.

</comment><comment><USER88> Been working for me fine on Safari and IMAP

</comment><comment><USER89> Working for me on Mac, but not in windows

</comment><comment><USER90> Seems to be working fine from Chicago...

</comment><comment><USER91> My Chrome crashed several times as well

</comment><comment><USER36> Chrome is now trending on Twitter lol

</comment><comment><USER92> I'm getting a 502 Bad Gateway error.

</comment><comment><USER93> It's working intermittently for me.

</comment><comment><USER94> Ops, something is broken - <USER3>

</comment><comment><USER95> Chrome crashed for me as well.

</comment><comment><USER96> crashes by itself with a 502 error on ubuntu. The chrome doesn't crash though

</comment><comment><USER97> It seems to work fine now.

</comment><comment><USER98> It's working for me now.

</comment><comment><USER99> Working here on Chrome

</comment><comment><USER100> Google is down again

</comment><comment><USER101> Seems fine to me...

</comment><comment><USER102> pop.gmail.com is not, and that's how I get my mail.

<comment><USER103> Me too, but it's working for me here.

<comment><USER102> I meant that it was not down.

</comment></comment></comment><comment><USER104> Up and running now

</comment><comment><USER105> I am disappointed.

</comment><comment><USER106> went down for me. need to get work done. oh god.

</comment><comment><USER107> Wow that's amazing. #1 news on HN already? This is pretty cool.

</comment><comment><USER108> Working in FF....

</comment><comment><USER109> And it's back up.

</comment><comment><USER110> google drive also same issue

</comment><comment><USER111> Works now!

</comment><comment><USER112> Error 502

</comment><comment><USER113> and... they're back.

<comment><USER113> and they're back down again.

<comment><USER113> FWIW I assumed gmail was down because of gchat going grey and saying it couldn't communicate. It turns out the mail is actually still working, so it's just gchat that's down.

</comment></comment></comment><comment><USER114> aaaaand it's back )

</comment><comment><USER115> time to switch to outlook.com

<comment><USER116> Or alternatively wait 2 minutes for it to come back up. C'mon - you can't complain about Gmail's uptime record.

<comment><USER36> I was just going to say this. Been using Gmail daily since 2004 or so and I can count on one hand how many problems I've had. Stellar record, though as I said I am too dependent on it personally.

</comment></comment></comment><comment><USER117> zombie day is upon us.

</comment><comment><USER118> GMail is working fine here (France) both my personal email and my professional email. No Chrome crashing. Linux Debian 64 bit.

I use different browsers (in incognito mode), from different user accounts, to surf the web / do online banking / browser hacker news etc.

No plugins, no "sync" (heck, I don't even know what that "synch" for Chrome is), no issues.

<comment><USER119> I have similar configuration. Fedora 64Bit, chromium and gmail work fine. No plugins for chromium, no sync, only a gmail tab is open. I use firefox for everything else. This bug seems interesting!

</comment></comment><comment><USER120> Hey guise I'm in Chrome right now, and it's working just ( _& $(_&#(*&# )#</comment>


Build an Add-In for Outlook.com, Outlook and Office 365 - <AUTHOR> http://channel9.msdn.com/Events/Build/2015/3-694

<comment><USER2> I spent a summer internship building an Add-in for Outlook. I think its a very undeveloped for market and I am excited to see MS continue to support it.</comment>


Two amateur sleuths discover ancient rock art in the plains of India - <AUTHOR> https://www.nytimes.com/2019/05/07/science/petroglyphs-rock-art-india.html <comment><USER2> That compass 🧭 pointing different north puzzled me, may be because of the materials they use to carve the figures

</comment><comment><USER3> there are many more mysteries of the past we have yet to uncover.

</comment><comment><USER4> Clearly the work of the children of the forest

Edit: That was a game of thrones joke for those who missed it</comment>


How did we end up with containers? - <AUTHOR> https://www.tedinski.com/2018/04/03/why-containers.html <comment><USER2> This is mostly a good post, but he doesn't mention one huge security _disadvantage_ of containers: When application artifacts all include their own versions of dependencies locked at build time, it becomes very hard to update a component that has a security fix. It's somewhat tractable if you own all the images — you "just" have to rebuild every application with the vulnerable component. But once you start accepting prebuilt images from elsewhere, you are at the mercy of the external source unless you want to fork the Dockerfiles.

It's the same lesson that a lot of people learned about static linking, with the zlib vulnerabilities years ago.

[https://www.linux.com/news/linux-kernel-netscape-affected- ma...](https://www.linux.com/news/linux-kernel-netscape-affected-major-zlib- security-vulnerability)

<comment><USER3> this is really about static vs dynamic linkage, regardless of the mechanism you use to effect run or build time binding of dependencies.

there are as always tradeoffs, but a few more arguments against dynamic:

by opening up a path (automatic updates) to a third party, you're providing a wide vector for those updates to cause new* problems (correctness, security) for your deployment, as well as fix old ones

transitive api compatibility across these upgrades is more of a statement of faith and effort of will than any real guarentee. in reality the compatibilities between the various components are piecewise, and if the graph gets big enough it can be really hard to find a compatible set of libraries.

runtime binary integration is always strictly worse than build time source integration, since there is tooling in the latter promoting consistency, and basically none in the former

since you'd really like to be able to deploy changes in your own* software with very little effort - dependency updates can ride on the same train for free.

presumably you have to have some intervention to restart your service against the new dependencies regardless. at that point its a question of the relative complexity of a dynamic restart of an existing service vs a build and deploy. in the limit these are both buttons.

from that perspective, dynamic updates are a helpful crutch for people who don't have a good handle on their own build, test and deploy. thats pretty far from being an arguable fundamental good.

<comment><USER4> > this is really about static vs dynamic linkage, regardless of the mechanism > you use to effect run or build time binding of dependencies

Are you familiar with the functional package management approach of tools like Nix ([https://nixos.org/nix/](https://nixos.org/nix/)) and Guix ([https://www.gnu.org/software/guix/](https://www.gnu.org/software/guix/))?

They use dynamic linking but store all packages in a content-addressed format, outside the usual FHS. Packages are free to rely on separate versions of their dependencies as needed. Packages are defined in a 'source-based' format, but because of the content-addressable storage strategy, both Nix and Guix can offer transparent binary caching.

Guix folks in particular are working on verifying the integrity of binary caches, so you don't have to blindly trust them, and they've developed a system they call 'grafting' which can safely and quickly replace vulnerable packages without recompiling.

Both Nix and Guix have some container infrastructure as well. I'm not as familiar with the Guix side, but Nix has tooling for deterministically generating Docker images and systemd-nspawn containers, so you can leverage these packaging tools at the same time as existing container deployment infrastructure.

I like your analysis of 'build time' vs 'runtime' integration of dependencies, and I think you might enjoy playing with/critiquing Nix and Guix, because they address these problems in a strange and powerful way. They use dynamic linking for deduplication and small upgrades, but try very hard to integrate everything they can at build time. I'd be interested to see where you think their approach is strong and weak, if you ever get a chance to try it out.

<comment><USER3> i dont really deal with these issues directly anymore, so no, I haven't had a chance to use any tools in the Nix family. but sure, once you eliminate the ambiguity around 'which bytes' then it hardly matters whether you distribute them in one chunk or several chunks.

What makes Nix more interesting than just that is that it actually provides tools to manage the dependencies and build. As much as I think owning your whole world is important, it can really consume alot of engineering resource just due to the state of the world. Since Nix signatures are transitive (as I understand it) it also captures the versions of the included tools, which is usually too far for most organizations to go. And while issues having to do with compiler versions are rare, they can really consume alot of energy trying to track down.

So, without having any firsthand experience, it seem like its as dependable as static linkage, and may be quite a bit more convenient.

</comment></comment></comment></comment><comment><USER5> The description at the end of the article about how package management doesn't have to be done in a way that shares all the files sounds a lot like a description of [https://nixos.org/nix/](https://nixos.org/nix/)

</comment><comment><USER6> I feel like containers (at-times) are the artifact organizational disfunction, the inability for teams to collaborate and a lack of engineering quality.

What's sad is that I believe this to be true for the overhwelming majority.

<comment><USER7> Mixed bag: containers applied right can solve some real problems, containers applied wrong cause some real problems.

</comment></comment><comment><USER8> I can't seem to find any easily accessible documentation on this, but it sounds like a container is basically an chroot jail: you copy over all the libraries and files into a subdirectory, chroot into it, and run. Am I right? And if so, what took people so long? Chroot has been around for quite a while.

The article sort of makes it sound like a lightweight version of containers would be putting everything in its own directory, rather than scattering everything in /usr/lib, /usr/bin, /usr/share, etc. Which is basically macOS' app bundles. I've never understood why other OSes didn't steal that idea. And while I hear a lot of griping about iOS and static libraries, basically what iOS is doing is creating a container, only since they call it an "application bundle" instead of "container" they get all this hate. But... Grandma Tillie (or whoever the user story for Linux on the Desktop back in the The Day was named) can actually figure out how to delete her Mac and iOS apps.

Seems like iOS is kind of containers writ large.

<comment><USER9> chroot is a filesystem namespace, and containers are basically just that plus some other namespaces. Prior to containers getting really popular I was using debian's schroot project and prior to that I was using solaris zones. There were other similar technologies prior to that but I wasn't really technical or even alive at the time. It's not new.

Here's what's made them so popular lately IMO. Docker improved the usability by adding the container registry and adding some better tooling around running a container.

Compare installing schroot plus configuring a new container plus running debootstrap plus potentially configuring lvm/btrfs/directory snapshotting to:

docker run ubuntu:lts /bin/bash

</comment></comment><comment><USER10> I like the focus on artifacts and repeatable testing.

Are full blown containers even necessary though? The newest version of systemd can do filesystem namespaces, and use cgroups to limit access to resources. [http://0pointer.de/blog/projects/changing- roots](http://0pointer.de/blog/projects/changing-roots)

<comment><USER11> Not even every Linux distro uses systemd, to say nothing about other systems on which one may want to host containers. Remember, there's more to containerization than just Docker and its consumers and dependencies.

<comment><USER12> Which production grade distros don't use systemd?

<comment><USER13> Gentoo!

 _ducks_

<comment><USER14> I think RHEL 6 also doesn't use it. But then you have bigger problems :)

</comment></comment></comment></comment></comment><comment><USER15> I have a less charitable explanation, but a container fan on our team convinced me recently to switch to fully static binaries which did indeed simplify many things. So there is something to be said for this in an age of cheap storage.

<comment><USER7> Static linking was the norm until someone figured out that all the copies of glibc were taking up a lot of space in a time when disk space will still expensive. Today it makes much less sense than it did back then but there is one more advantage: updating a library (which is trivial because almost all these systems are online all the time now) will automatically cause all new instances of the rest of the software on the system to use the new library without having to re-link all the binaries.

<comment><USER16> "there is one more advantage: updating a library (which is trivial because almost all these systems are online all the time now) will automatically cause all new instances of the rest of the software on the system to use the new library without having to re-link all the binaries."

In Windows this is called "DLL hell". Too often the new version will have some subtle incompatibilities breaking a lot of stuff.

I am a fan of static linking or putting DLLs into a dedicated folder so these shared libraries are actually not shared.

<comment><USER17> Windows does a good job of versioning the actual system DLL's like user32.dll, kernel32.dll, and so on.

The run-time libraries on top of this aren't part of the system. Each application brings its own and so of course hell will break loose if you mix and match.

Windows has no malloc or printf (not for public use anyway).

In the POSIX world, the user-space C run-time support is part of the platform so it is carefully versioned, just like kernel32.dll on Windows.

User space compiler run-time support isn't part of the platform on Windows; it is not that carefully versioned. Everyone is supposed to provide their own. If you have a compiler from Acme, Inc, you use the Acme C library with Acme malloc and Acme printf.

> _putting DLLs into a dedicated folder_

Which actually _works_ on Windows, that's the thing.

Searching for shared libs in the same directory as the executable is very nice: like me.c finding its #include "me.h" next to it.

The Unix people didn't pay attention to their own programming language when they designed shared libs.

<comment><USER18> Most compilers used by app developers don't use this, but...

link /dump /exports c:\windows\system32\msvcrt.dll

        Dump of file c:\windows\system32\msvcrt.dll
        Section contains the following exports for msvcrt.dll

        00000000 characteristics
        57898F96 time date stamp Fri Jul 15 18:36:22 2016
            0.00 version
               1 ordinal base
            1317 number of functions
            1317 number of names

        ordinal hint RVA      name
        ....
           1160  487 00019DE0 malloc
        ....
           1183  49E 00048940 printf

<comment><USER17> Most compilers used by app developers don't use that for good reason: Microsoft says that it is an unsupported, undocumented library which is off limits to application developers. Programs that are part of Windows itself use it.

[https://blogs.msdn.microsoft.com/oldnewthing/20140411-00/?p=...](https://blogs.msdn.microsoft.com/oldnewthing/20140411-00/?p=1273)

</comment></comment></comment></comment></comment></comment><comment><USER19> > In short, there's no reason why apt and dnf or whatever couldn't work in a > similar way npm or bundle do, except that Linux distributions seem to be > disinterested. (And occasionally throw a specious fit about "bundling" when > features like this are proposed. Or are unwilling to understand why the > ability to install multiple versions of a package is necessary.)

Wouldn't this just require tighter integration with environment modules ([http://modules.sourceforge.net/](http://modules.sourceforge.net/)) or similar?

</comment><comment><USER20> > How did we end up with containers?

1) You bought stuff. 2) Bonus!

</comment><comment><USER21> Containers != Images</comment>


Ask HN: How should a programming language accommodate disabled programmers? - <AUTHOR> I work on programming languages (as a career & hobby) and I'd like to make sure that my main language project is designed with accessibility in mind. I need some guidance & opinions from people with disabilities (e.g., blind or visually impaired people, or people with mobility issues) about your pain points with existing tools.
This doesn't need to be just about the language itself, but the whole experience of developing with it, e.g., tooling, error messages, documentation, editor integration, &c.; as simple as "Avoid making me press Shift" or as involved as specific problems with existing tools and what you wish they did better. I'd also welcome examples of tools that do things particularly well!
So far I've had/implemented a few general ideas:
1. Making whitespace-sensitive syntax, like in Python & Haskell, optional syntactic sugar for explicit brackets & separators. It can also be turned off entirely, if e.g. you work with a screenreader and prefer it not need to speak all the indentation.
2. Striking a balance between concision and avoiding excessive punctuation-based syntax. I've also tried to make sure that visually similar characters have clearly distinct functions, so it's less likely to mix them up—or if they are typo'd, at least the compiler should reliably detect this and produce a useful diagnostic.
3. Working on integration with existing editors (through the Language Server Protocol, an Emacs mode, &c.), so ideally you can continue to use the editor you're comfortable with that supports your setup.
4. Allowing the interactive mode (sort of a souped-up REPL) to be customised to support screenreaders, colour settings for colourblind people, adapting gracefully to large fonts, and so on.
I'm certain there are plenty of things I'm still missing, though! So I'd really appreciate any help, personal stories, or links to the work of similar initiatives (like Accessible Scala) that you can offer. Thank you! <comment><USER2> Lisp:

\- Avoids the use of gratuituous special characters: (a b c)

\- use-dashes-in-symbol-names-instead-of-underline-so-its-easier-to-type (you can still use underlines or most any special character, but we like to keep it simple and easy).

\- has a simple prefix syntax, that makes it easier to read and understand complex expressions: (loop (print (read (eval))) So no risk of confusing special characters or syntax: the meaning is clearly labelled by the first symbol of each expression!

\- is not whitespace-sensitive, how can you see the size of whitespaces when you're blind?

\- includes a reader and a pretty printer, so the code can be processed and formated automatically easily for either sighted or blind programmers.

\- time-sharing was invented for the lisp REPL by the authors of lisp!

\- as a good integration with emacs, which itself has a good integration with various tools such as screen readers, vocal commands, etc, and it's fully customizable.

[http://cliki.net/](http://cliki.net/) [http://common- lisp.net/](http://common-lisp.net/) [https://en.wikipedia.org/wiki/Common_Lisp](https://en.wikipedia.org/wiki/Common_Lisp)

<comment> dan-robertson Well it seems that OP needn't bother as this problem is already solved. You wrote (loop (print (eval (read)))). How does that go with a screen reader? Like:

Bracket loop bracket print bracket eval bracket read bracket bracket bracket bracket?

The key thing I think is balancing and shifting parens.

      (loop (print (eval)) (read))

Is quite hard to sound different from

      (loop (print (eval (read))))

And more crucially what about the difference between these two:

      (let ((x (f))) (g x) (g x))
      (let ((x (f)) (g x)) (g x))

(I think writing these on a single line makes them written more like they might be spoken)

On the other hand I think being able to modify the syntax structurally is a big advantage.

Going back to the topic of the OP I think a useful thing is putting functions after their arguments, and optimising to have single arguments or most non- main arguments being typically small. For example something more like

      read
      | eval
      | print
      | loop

And maybe some way to do arguments like

      read stdin
      | eval some-environment
      | print :pretty
      | loop

<comment><USER3> _"Bracket loop bracket print bracket…"_

A screen reader need not literally read what's on screen. It typically doesn't with prose, where punctuation isn't spoken, but affects timing and intonation, and abbreviations often are expanded (iOS speaks "Dr. John St." as "Doctor John Street", for example, but "St. John Dr." as "Saint John dee-ar". MacinTalk used to know that 'Dr' means 'Drive')

So, it need not do that here, and could say

"call _read_ , _eval_ it, _print_ the result, and call _loop_ on _print_ 's output"

, using intonation or voice to indicate the difference between content read from the screen and text describing it.

Farfetched? Maybe, but take a look at what screen readers do with html.

A screen reader that knows lisp semantics could go even further, and replace _loop_ by _repeat forever_ or something like it.

<comment> dan-robertson Requiring a sufficiently smart screen reader seems a bad way to go. 30 years on from CLtL we still don't have a sufficiently smart compiler and I would argue that that problem is easier. One thing is that this works "better" with one-argument functions. Consider:

      (with-open-file (*standard-output* foo)
        (print x))
      (print y)

Vs

      (with-open-file (*standard-output* foo)
        (print x)
        (print y))

How do you read the first? As "print x, now with-the-file foo-open-as- _standard-output_ it; then print y"? Or maybe "with foo opened as standard output, print x; now print y"?

This seems more reasonable but how do you write the second example? Like "with foo opened as standard output, print x; also print y"?

There are reasonably large semantic differences in such cases and many programming languages, including lisp, express them with subtle hard-to- pronounce differences in indentation or parenthising of expressions.

</comment></comment></comment></comment><comment><USER4> One of the software engineers where I work is completely blind. I've never had a chance to interact with him as he's in a remote office unfortunately. He mainly writes in Python, bash, and C.

From what I understand, every project he works on has strict formatting requirements (can't commit until the linter passes, etc.) and his screen reader is programming language aware.

Although, to be honest, I feel that the thing he relies on most is his rather amazing ability to remember most of the exact contents of whatever file he's working on.

<comment><USER5> I would find it very interesting to read your coworker's account of what programming is like. Or anyone's account who has to approach programming differently compared to the average person. I'd love it if more people blogged in general.

<comment><USER6> Check this out: [https://www.vincit.fi/en/blog/software- development-450-words...](https://www.vincit.fi/en/blog/software- development-450-words-per-minute/)

</comment></comment></comment><comment><USER7> T.V. Raman (author of Emacspeak) has said that "S-Expressions are a major win" for visually-impaired users because they give you a good way to navigate the code structurally ("go to beginning of expression" is more accessible than "go up one line").

[https://tvraman.github.io/emacspeak/manual/Emacspeak-And- Sof...](https://tvraman.github.io/emacspeak/manual/Emacspeak-And-Software- Development.html)

</comment><comment><USER8> My struggle is typing. I use an onscreen keyboard ([https://www.blakewatson.com/journal/writing-and-coding- with-...](https://www.blakewatson.com/journal/writing-and-coding-with-the- accessibility-keyboard/)), which I have heavily customized for web development.

I would appreciate terseness. For example, I love how in JS, I can do this:

``` var cat = whichCat(); var catPosts = posts.filter(post => post.cat === cat); ```

Whereas in PHP, I have to do this:

``` $cat = whichCat(); $catPosts = array_filter($posts, function($post) use ($cat) { return $post->cat === $cat; }); ```

So much extra typing.

DISCLAIMER: didn't test this code so chance of typo is 99%.

<comment><USER9> Have you had any luck with programming by voice?

[https://github.com/melling/ErgonomicNotes/blob/master/progra...](https://github.com/melling/ErgonomicNotes/blob/master/programming_by_voice.org)

</comment></comment><comment><USER10> Another blind developer here with his two pens. I like python because it has no braces. Sometimes the screen reader does not read them or if it does, it takes time to process the info and you still could be confused about the level of nesting. That's why in university I reformated all of my lisp code to follow the indentation rules of python as it helped me keep track. Generally, if the language has no too much strange symbols with important meaning, they are all just text to be read. So, the language is not an issue for me, but the tools to read/write/compile/debug. In that line of thought, if it works on the command line, it is good. Make it readable, make it verbose and avoid fancy syntax so that there is no ambiguity when reading.

<comment><USER11> I never thought about the concept of programming in symbols that you've never before seen. That's rather fascinating. The human brain is incredible.

<comment><AUTHOR> I'm not sure, but based on what statistics I can find, it seems most blind people aren't congenitally blind, so they probably have some familiarity with the symbols, maybe depending on how old they were when their visual impairment manifested. And of course you could always learn the shape of an unfamiliar symbol by feeling a physical representation of it—like on embossed paper, or those letter-shaped fridge magnets—but I dunno how common it is to do that.

If you don't know the symbol at all, though, that could definitely make things more challenging to learn, since then the notation is (even more) arbitrary. A lot of programming languages' symbol choices are _visually_ mnemonic: Perl has "$" for scalars, "@" for arrays, and "%" for hashes because dollar-sign _looks like_ S for scalar, at-sign looks like A for array, and percent-sign looks like a pair of things (a key and a value), but there's nothing about these symbols semantically or in their pronunciation that suggests their Perl meanings.

<comment><USER10> It is not about if I've seen the symbol or not. { for example is read as "left brace". It takes the screen reader the time to pronounce two words with ambiguity left. What about ${variable}? You have 3 extra symbols totaling five words to surround a single variable. Redundant and abhorrent.

</comment></comment></comment></comment><comment><USER12> Blind people already do programming. I know a blind guy who can code really fast, much faster than my colleagues, no idea how though.

Shouldn't you be researching how they code now and then work from there? I actually feel like current way of coding using text works very well for blind people.

<comment><USER13> I have arthritis and my hands had been affected a lot, I actually like it when the languages are more verbose. Because I can use "Procedural memory" and can be more automatic. My hands already know how to type those words. Symbols or short words force me into more conscious typing and/or move my fingers in a not familiar way.

</comment></comment><comment><USER14> It is interesting that you're getting a lot of suggestions from people that don't claim to have disabilities. Perhaps few of them read hacker news?

It seems that their needs would vary. One thing you could do is try to an interface to test it yourself.

I tried to write and edit a document once using just voice commands. (Let's say someone has carpal tunnel and needs to use voice commands). It was eye opening. I realized how much more frustrating it is to go back and try to delete or fix something than anything else. And if the software didn't recognize an unusual word, it was really hard.

Dragon dictate -- the software I used -- had already learned a lot of this over the years, and there were many commands for changing that, or deleting up to a point. The hard part was moving the cursor to exactly one spot and then talking in a new word.

Anyway, if you tried something like that you would learn a lot.

Imagine if you are blind folded, and have to hear the program and then have to keep it all in memory. Well, that is a _lot_ to keep in your working memory. I would want some kind of canonical "view" to always get to in order to find my way around.

I am glad you are working on this.

<comment><USER5> > I tried to write and edit a document once using just voice commands. (Let's > say someone has carpal tunnel and needs to use voice commands). It was eye > opening. I realized how much more frustrating it is to go back and try to > delete or fix something than anything else. And if the software didn't > recognize an unusual word, it was really hard.

I've tried that as well. It was very frustrating. I used the Windows speech- to-text features.

Programming code is made to be typed and read. If you can't do either of those reliably, you'll be simulating that you can, which sort of by definition can't work well, because if you could simulate being able to write well, then you wouldn't even call that a disability, you'd just be different.

What I'm getting at is that the problem is simulation. Ideally, there would be a way to program by voice (or with a mouse, etc). Not program by typing code with voice, but find a way to describe a program (i.e. program) via voice. A voice-centric toolkit. I hope I'm not being too vague.

What we have now is such a typing-centric development world that we don't even think about all the other possiblities. Isn't the modern laptop just a really fancy version of a 100 year old typewriter?

I think Bret Victor would have a lot to say about this [0].

[0] [http://worrydream.com/#!/TheFutureOfProgramming](http://worrydream.com/#!/TheFutureOfProgramming)

</comment></comment><comment><USER15> As an aside, I've been working on accessibility on the side, as part of my work on sway[0]. My current goal is, as a sighted person, to be able to comfortably and productively use my computer for all of my normal tasks without any displays plugged in.

To this end I've been making plugins for Vim and WeeChat, and a script for sway:

[https://github.com/SirCmpwn/vimspeak](https://github.com/SirCmpwn/vimspeak)

[https://git.sr.ht/~sircmpwn/dotfiles/tree/master/.weechat/py...](https://git.sr.ht/~sircmpwn/dotfiles/tree/master/.weechat/python/talkative.py)

[https://git.sr.ht/~sircmpwn/dotfiles/tree/master/bin/swaytal...](https://git.sr.ht/~sircmpwn/dotfiles/tree/master/bin/swaytalk)

If you or someone you know would find these useful, please reach out so I can learn more about your needs.

[0] [https://swaywm.org](https://swaywm.org)

</comment><comment><USER16> I founded and co-own the google group Blind Dev Works. I have posted this Ask to it. It has at least a couple of blind developers on it and a stated purpose of improving programming tools for blind developers. You are welcome to join it.

[https://groups.google.com/forum/#!forum/blind-dev- works](https://groups.google.com/forum/#!forum/blind-dev-works)

(I am seriously visually impaired, but not blind. I know a little HTML and CSS and I have a part-time position with the spiffy title of Webmaster, but I'm not really a programmer.)

</comment><comment><USER17> Moore indicated one of the motivating factors in choosing colour was to accommodate his failing eyesight[1]

I have previously attempted to program blind and reported some of my experiences[2].

[1]: [https://en.wikipedia.org/wiki/ColorForth](https://en.wikipedia.org/wiki/ColorForth)

[2]: [https://news.ycombinator.com/item?id=9284567](https://news.ycombinator.com/item?id=9284567)

</comment><comment><USER18> Just want to note that in Haskell, whitespace syntax _is_ syntactic sugar for brackets etc. I don't recall that being the case for python. Interesting tidbit, some of the big names in the Haskell community have very idiosyncratic coding styles that use the bracket look.

<comment><USER19> Can you point out an example or two the bracket style that I could take a look at? Thanks.

<comment><AUTHOR> Simon Peyton-Jones is (was?) known for writing blocks in "aligned" instead of "hanging" style, with separators in prefix:

        someFunction =
          do { foo
             ; mx <- bar
             ; y <- case mx of { Just x -> do { baz
                                              ; pure (quux x)
                                              }
                               ; Nothing -> do { fnord
                                               ; blurch
                                               }
                               }
             ; xyzz y
             }

I find it nice enough to read, particularly because it leads to rapidly increasing indentation and consequently discourages deeply nested code, but it's a bit of a pain to edit & diff. I would write the above like this:

        someFunction = do
          foo
          mx <- bar
          y <- case mx of
            Just x -> do
              baz
              pure (quux x)
            Nothing -> do
              fnord
              blurch
          xyzz y

This prefix delimiter style is actually fairly standard in Haskell not for "do" notation, but for records and lists, since Haskell doesn't allow a final trailing comma in these structures:

        list :: [Text]
        list =
          [ "this"
          , "that"
          , "the other thing"
          ]

        data Numbers = Numbers
          { numI :: Int
          , numF :: Double
          , numS :: Text
          }

        record = Numbers
          { numI = 1
          , numF = 1.0
          , numS = "one"
          }

</comment></comment></comment><comment><USER20> At GopherCon 2018 Julia Ferraioli gave a talk titled "Writing Accessible Go". She's challenged with some vision impairment, and shares some of her struggles in trying to be a programmer with those challenges. Of course it's contextually about Go, but I think what she talks about applies to current languages and those to come in the future.

\- [https://www.youtube.com/watch?v=cVaDY0ChvOQ](https://www.youtube.com/watch?v=cVaDY0ChvOQ)

</comment><comment><USER21> I've seen some programmers code using voice. This is really handy for people without functiong hands or fingers. They tend to use voice recognition software like Dragon and various plugins.

I'd say from a programming language point of view, having keywords that are short (single word would be ideal) and phonetically distinct is really important.

One python programmer I watched on Youtube made his own vocabulary of strange sounds that he trained his software to recognise and translate to real keywords.

<comment><USER22> This might be the programmer in question. Pretty impressive.

[https://www.youtube.com/watch?v=8SkdfdXWYaI](https://www.youtube.com/watch?v=8SkdfdXWYaI)

<comment><USER9> There are several other newer resources:

[https://github.com/melling/ErgonomicNotes/blob/master/progra...](https://github.com/melling/ErgonomicNotes/blob/master/programming_by_voice.org)

</comment></comment></comment><comment><USER23> > _Making whitespace-sensitive syntax, like in Python & Haskell, optional > syntactic sugar for explicit brackets & separators._

Interesting question. A few years ago, I worked with a blind mathematician. I was an undergraduate T.A. and he was the main T.A. of the course. He used the screen reader a lot. In particular, he has the list of exercise in LaTeX. We read aloud the grades of the students and he wrote them in the Excel form.

I don't remember him using a programming language (excluding LaTeX). The indentation looks like a difficult problem, even if the language has explicit brackets. Does the screen reader say "Tab Tab print ten semicolon"? Does it ignore the indentation? Spaces vs tabs? ...

Do you have some group of blind programmers that you can ask about their current setup?

<comment><USER24> Not knowledgable about screen readers, but maybe having the increase in indentation result in an increase in pitch of the screen reader voice could be an interesting approach for this.

<comment><USER25> You beat me to this idea by five minutes!

Another bonus to this approach is that it enforces a style guide. Overly complicated and nested programs become more difficult to understand, and excessive nesting becomes literally incomprehensible as it spirals out of the human hearing range.

I wonder if you could also use different voices for different things. Code could be read in a masculine tone, code blocks in a feminine tone, inline strings with an Australian accent.

</comment></comment></comment><comment><USER26> Perhaps instead, adapt a screenreader that understood C syntax, and instead of reading punctuation would read it in a higher level form, such as:

        for (int i; i < 10; ++i)

        "for each int i from 0 to 10"

instead of:

        "for left paren int i semicolon i lessthan 10 semicolon
        plusplus i right paren)"

<comment><USER27> This is what the Accessible Scala initiative did

[https://www.scala-lang.org/blog/2018/06/14/accessible- scala....](https://www.scala-lang.org/blog/2018/06/14/accessible-scala.html)

</comment></comment><comment><USER28> Have you looked into projectional-editing? The basic idea is that your code is stored not as text, but as data. The data is then projected into a textual format for editing.

That seems like the best way to support disabled programmers, as it gives them the flexibility to make whatever syntax works for them, as long as your core AST is simple enough.

<comment><USER17> I can attest to this: Paredit is as easy to use with eyes as it is without.

</comment></comment><comment><USER29> > I'd really appreciate [...] links to the work of similar initiatives

Take a look at Quorum, a "programming language which is designed to be accessible to individuals with disabilities and is widely used in schools for the blind".

[0] - [https://quorumlanguage.com/](https://quorumlanguage.com/)

[1] - [https://www.youtube.com/watch?v=X29BuzGHlBs](https://www.youtube.com/watch?v=X29BuzGHlBs)

<comment><USER30> My first thought as well. It is an interesting project!

</comment></comment><comment><USER31> Working with handicapped programmers with vision and hand issues I feel programming tools like Mu Pyhton and Blender were invaluable in giving the programmmer graphical feedback. Both Mu and Blender allowed interfacing with hardware in new ways. He is now a biomedical engineer at Medtronics designing physics models for medical devices. He started using Maya, Blender, Logo, Scratch, Python. He was trained at the NM Supercomputer Challenge in 3 Day events at New Mexico Tech in Matlab, Jupyter Notebooks, R Studio, AI and machine learning. He also build Raspberry Pi, Arduino projects after taking algebra in 4th grade and electronics at community college in 5th grade. Computers have allowed him to excel in almost every academic STEM area. He has had internships in bioiformatics and medical device analytics. His programming/electronics skills are not from the classroom but from multiple projects he developed.

</comment><comment> dan-robertson One thing which I think might be useful for speaking code is to try to avoid needing a mental stack or going backwards as you go through code (at least for English speakers. Maybe other languages are different). For example consider reading aloud:

      x = some_function(something_else(y), z)

You first need to keep in mind "x =", then "some_function", then think about what something_else(y) means, remember about some_function, think about z, then remember it all goes into x.

Now compare:

      something_else(y)
      -> some_function(z)
      :> x

Read forwards as "do something_else(y), now take it and do some_function to it, modified as z; now put it into x."

<comment><USER32> Yes, for me SQL is very hard to reason about just because of the way it's "phrased"

It's much easier for me to interpret JavaScript or PHP method chaining. I find myself struggling when I can't use an ORM.

<comment> dan-robertson I disagree with this. I think sql is actually mostly very good, with the exception that maybe the FROM clause should come before the SELECT.

<comment><USER32> It's probably just the way my brain works. After a SQL statement goes to more than ten lines or so I have to study it very hard to understand what's going on.

Maybe it's the way I was taught.

</comment></comment></comment></comment><comment><USER33> Just wanted to chime in to say thank you for your consideration of visually- impaired programmers with suggestion 1.

</comment><comment><USER34> Blind programmer checking-in, here are a few thoughts sparked by the comments that I've read…

Disclaimer: these are my thoughts, and should not be generalized to all blind programmers.

First, let's start with the supporting technologies, mainly screen readers. The most popular screen reader is Jaws for Windows (expensive product), followed by Non Visual Desktop Access (opensource product), distantly followed by VoiceOver (your only choice for Apple products). My main day-to-day driver is NVDA, but I also use Jaws for my job. I do not use a braille display. The IDEs that I use are Visual Studio (C# development) and Visual Studio Code (Python and Javascript development).

Indentation-sensitive languages such as Python really aren't that difficult to use, once you figure out how to get your screen reader to announce indentation levels. Typically, the screen reader only announces indentation changes when there is a difference from the line that you are coming from. A sample Python function would read as follows as I press the down-arrow to read line-by-line (note that I'm purposely not putting in line breaks, since an audio-based screen reader is inherently serial):

"def foo left paren right paren colon, four spaces number say hello world, print left paren quote hello world quote right paren, zero spaces blank"

Interestingly, I find lisp one of the most difficult languages, since there are so many parentheses, and it's difficult to keep track of what nesting you are in.

Screen readers are not programming language aware. It's all text to them.

Using pitch to communicate information is more distracting than anything. Imagine that you were having a conversation with someone, and every few words, their voice completely changed. It makes understanding the meaning of what they are saying more difficult, since your brain is too busy going "hey, something changed!"

Some additional reading that I recommend is "An Exploratory Study of Blind Software Developers", which can be found at [https://ciigar.csc.ncsu.edu/files/bib//Mealin2012-BlindDevel...](https://ciigar.csc.ncsu.edu/files/bib//Mealin2012-BlindDevelopers.pdf). That identifies some programming challenges that participants face, as well as some of the areas that blind programmers self-report as excelling in. Full disclosure, I was the primary researcher on that study.

Finally, a mini soapbox rant: something that I see quite often is people doing blindness "simulations" for a short period of time. They then write up their experience, which isn't a bad thing, but then present their work as "I found this hard, so all blind people must find this hard." Identifying when a task has a large learning curve is important, but also do keep in mind that people who are blind have significant experience in identifying ways to overcome potential accessibility problems.

</comment><comment><USER35> This has already been alluded to, but please let me do everything I can via the mouse, especially when reviewing and reading code. I'm flat on my back with the monitor above me, it's infuriating to grab the keyboard for a single character of input, unnecessarily, then go back to the mouse. I might also mention that those with sensory processing disorder (such as those on the Autism Spectrum) will want to change the background color. (word)

</comment><comment> GuB-42 Just a random thought. Is there a programming language for dyslexics?

Considering that dyslexia is a reading disorder, I suppose that the programming language can be really important.

<comment><USER3> Some languages help with misspellings by not just saying _"'foobra' is not a function"_ , but also _"but 'foobar' is. Did you mean to write that?"_.

I guess you could also require the edit distance between identifiers to be at least X, but I expect that to be wildly impopular, if only because its effect on identifiers in libraries.

</comment></comment><comment><USER36> Slightly off-topic: how do blind programmers read code? Does the screen reader recite it aloud and just say "int main left-paren void right-paren open-brace int i equals zero...", or does it use some other kind of auditory vocabulary to make it more meaningful to the listener?

I've been thinking about this alot lately because I've been wondering how I could get better at programming while driving on my daily commute.

<comment><USER37> The blind people I have known use a Braille display to work with a computer

[https://en.wikipedia.org/wiki/Refreshable_braille_display](https://en.wikipedia.org/wiki/Refreshable_braille_display)

<comment><USER38> Braille's somewhat dying off as screenreaders become more integrated into computer systems - a system reading to you (usually at 3x speed as well) has massively more information density than a Braille display, to the point that it's becoming less usual to learn Braille in the first place.

<comment><AUTHOR> Last I knew, Braille displays are also pretty expensive, slow, and prone to breakage. Cool idea, but doesn't work as well as a screenreader in practice for most people.

</comment></comment></comment></comment><comment><USER39> Sure this problem can be addressed at the language layer, but as you've alluded to, I think it would be more applicable to address this issue at the text-editor / IDE layer or even the build tools.

There's tons of IDEs that make developers better at coding, with things like automatic syntax checking, refactoring, inline debugging, autocomplete, etc. Would it make more sense to develop a developing environment that makes disabled developers better at coding, with whatever features would make their experience better?

It would probably be easier to get a disabled developer to use your editor than to get a disabled developer to use your language. From what I can gather, it's hard enough to get employment as it is for them (maybe they can only work remote, or maybe they can be physically in the office but they're blind). I'm not sure if they have the luxury of being able to choose what language they get to use. But I'm sure their employers would allow them to use the IDE & tooling that works for them so long as they output code that fits the company stack.

</comment><comment><USER40> Thinking about disabilities that are not necessarily physical such as dyslexia, adhd, and other things that affect cognition--I would say an optimal programming language should be as easy to understand and read as possible. This would mean choosing the style of the language and the syntax so that it optimizes for readability. Also, removing the amount of the context someone needs to understand a piece of code. Perhaps this could be accomplished by strict enforcement of modularity and things like auto-generated or required documentation so that interfaces can be understood without diving into them if possible.

Obviously, inherent to programming is diving deep into chained function calls and managing all those levels in abstraction in one's mind. However, for someone with a limited working memory for whatever reason--adhd, depression, chronic pain, anxiety, headaches and more--having this minimized as much as possible would be a lifesaver.

</comment><comment><USER41> Forgive me if I missed it, but I don't believe I saw any mentions of ruby in this thread.

I feel like the English like syntax and use of keywords instead of symbols would be very beneficial for people with disabilities.

I guess python is in a similar vein, but ruby doesn't rely on white space for its blocks, which I think is a real plus.

</comment><comment><USER42> A while back I was experimenting with something akin to "syntax highlighting" with sound instead of color. The idea is to play different tones/noises depending on where your cursor is located in your code. Rough proof of concept that you can try out: [http://marycourtland.github.io/AuralJS/](http://marycourtland.github.io/AuralJS/)

This was just a fun experiment - I'm not blind or visually impaired - but I imagine that the concept could useful for programmers who depend on screen readers. It could be simplified as well; e.g., adjust the pitch or timbre of the voice depending on the nesting level of code.

</comment><comment><USER43> Hey, kudos to you for thinking about this! Background: I'm totally blind, have programmed for nearly 3 decades, kind of do the in and out of half a dozen languages thing these days. Today's favorites are Rust anywhere I can get away with it, Python because it runs in places where I need it (Home Assistant, Mycroft, etc.) and JavaScript because if I hold my nose and don't think too much about the atrocities I'm committing, I can run the same or similar code in various form factors. I'll try to give a few pointers. Note that these are specific to blindness, and specific to me. I don't claim to speak for the disabled population as a whole, as we're kind of a grab bag.

1\. Indentation: Pretty much a solved problem at this point. If I were reading Python code line-by-line, my editor might speak something like (not sure if my newlines will make it, but imagine them where they should be): def hello(world): 4 spaces print("Hello, world.") 4 spaces 1 tab 4 spaces print("What was I thinking when I indented this line?")

So I wouldn't worry too much about that. I've never had issues with an indentation-based language, and anyone blind who does likely just needs to change their tooling a bit. This is usually just a checkbox in the screen reader settings, so doesn't even usually require an editor/IDE change.

2\. Avoid crazy symbols. Scala gave me some grief with this, with every library author having method names like %^&@^$# because I assume that set of symbols looks like performHttpRequest(...) in some visual way. I exaggerate a bit. Only a bit. Note that operator overloading is fine, at least from an accessibility perspective. It's when people decide that a series of connected punctuation symbols evokes the idea of making an HTTP request or opening an Option that I start to get annoyed.

3\. Create good command line tooling. Rust has this nailed. I like how Rust's own installer just uses rustup under the hood, or at least I think it does, and every blog post advertising a new component also includes the rustup incantations to grab it. I assume the editor interfaces are as nice or nearly so. I guess the takeaway is, package your language installation tooling in a library so you can invoke it from the CLI, editor plugins, etc.

4\. Put error messages at the bottom of stacktraces rather than the top. Python does this right, and everyone else gets it wrong[1]. Say you're running a compiler from your command line. You get an error, and your cursor lands on the input area, ready for a new command. As a screen reader user, you discover that error by entering your window's review mode and moving up. With JavaScript, Rust, and just about everything else, I have to arrow through the callstack in reverse as I move up the screen to the line containing the error. Python puts this error last, near the input cursor, so all you're doing is arrowing up a couple lines. It's a few seconds per error, but can add up immensely over the course of a day. NPM, infuriatingly, shows the error, followed by disclaimer text that the error isn't in NPM, then barfs up an NPM error just to confuse things. So any JS package I use that uses NPM for its scripting requires arrowing back through _2_ stacktraces to find the original error. It's enough to drive me to drink.

I can probably come up with more, but I haven't finished my coffee yet. Perhaps that's a good thing...

1\. Right and wrong are of course subjective. This is just one blind dude's opinion, take it for what it's worth.

<comment><USER44> Are Unicode characters a problem for the tools you use?

For example, some languages will let you use λ instead of lambda. Or when trying to define the logistic function, I sometimes find myself writing

      σ(x) = 1.0 / (1.0 * exp(-x))

Or the Julia language has ≈, which tests if two floating point numbers are approximately equal. Visually, this is a reasonable symbol, it's not like one of the weird functional programming spaceship operators. But I have no idea what a screen reader would read.

Sometimes this sort of thing lets code correspond almost exactly to the notation in papers. It is a minor aesthetic improvement, but if it breaks screen readers and other tools I'd rather just write out "sigma" or "lambda".

<comment><USER43> My screen reader, Orca under Linux, read those as "sigma" and "almost equal to." So I suppose those work, though I'd have to hit Google to find out how to type them. :)

<comment><USER45> The NVDA screen reader for Windows also reads these symbols. So it looks like they're not a problem.

</comment></comment></comment></comment><comment><USER46> I'll be honest, I don't have any answers for you—but this is a really interesting question, and I'm looking forward to reading what other HN readers suggest.

</comment><comment><USER47> >Making whitespace-sensitive syntax, like in Python & Haskell, optional syntactic sugar for explicit brackets & separators.

That shouldn't matter with an IDE or plugin. If static analysis can identify the blocks -- and it has to! -- the screen reader can just read it as if it had your preferred block notation rather than noting the whitespace.

<comment><USER48> You also need to read coding books, documentation examples and webpages, so having to use an IDE is not the best solution.

<comment><USER47> Seems like the real problem is the lack of interoperability between a special coding parser and arbitrary snippets of online code.

</comment></comment></comment><comment><USER49> I don't have any specific advice here but I can share that I one worked with a physics professor who is quadrupelegic and he is one of the fastest most productive programmers I have ever seen. He worked in C and C±+ mostly, and typed with a stick which he held in his mouth. Don't underestimate peoples' adaptability.

</comment><comment><USER50> I do rough accessibility testing with JAWS on my company website, before we get people in to give it a thorough going over.

I would suggest you try it yourself, and download JAWS and write out some simple Hello World and figure out the challenges you face and then get in touch with disabled programmers and advocates.

</comment><comment><USER51> Bootstrap is doing some work in this space: [https://www.bootstrapworld.org/blog/accessibility/User- Inter...](https://www.bootstrapworld.org/blog/accessibility/User-Interface- REPL.shtml)

</comment><comment><USER52> i recently broke my two fingers on my right hand and could only code with the left hand (i am right handed) would have loved intellegint auto complete. And speach to text interface. That would be cool

</comment><comment><USER53> #3 is a good start.

I can't really think of anything that would greatly enhance my current Linux/tmux/emacs setup.

</comment><comment><USER54> What about Deaf programmers like me? How are they going to survive interviewing?

</comment><comment><USER55> Maybe we should train to code without screen: just a keyboard and a headset.

<comment><USER56> I think this is a very good idea. Several years ago, I learned how to browse the web with a keyboard and screen reader. Honestly, picking up that skill made me a noticeably better software developer. Prior to that experience, I had a vague idea about accessibility, but for the most part, it was just about checking a box when I was going for certain types of contracts. But, once I got into the screen reader flow, all of my formerly vague ideas became really solid concepts. I build much more accessible applications now because of this knowledge.

</comment></comment><comment><USER57> 1\. Do indentation right. One of the hardest things to do with a screen reader is indenting to a symbol. If we have a statement that doesn't fit on a line, it's much easier to increase the indentation by one level than to make the line start at the position where a symbol like ( is. The screen reader can tell you how many spaces of indentation you have, but figuring out where that symbol actually is and if it looks good is a real pain. This also applies to other situations where the exact number of whitespace matters like making struct declarations in c or go into a table, where one column is the name, one is the type and one is the comment, and spaces are used for alignment. If you really care about screen readers, I think tabs are a better idea for indentation, I feel they're a bit easier to use, though that may just be my preference. One language that got this horribly wrong is python, four space indentation and a lot of starting the next line exactly below a particular character on the previous one. A language that really got this right is go. They use tab indentation and they have that amazing tool called go fmt that basically does all the work for you. It basically formats your code in the standard go way. Yes, go aligns structs with spaces but I don't particularly care in that situation. I never use that convention in my code, I just run go fmt before committing and I'm sure everything looks right. In my opinion, alignment with spaces is the hardest thing to do when developing with a screen reader and it's really hard to avoid when your code convention requires it and you don't have a tool that does it for you. 2\. Make error messages textual. A message like error at line 10(25), invalid syntax where 25 is the column is much easier to read than error at line 10, followed by the line with a ^ under the character in column 25. Another thing Python does wrong.

3\. If you make a GUI framework, use native controls. Screen readers aren't magical pieces of software that do their things using arcane spells, to read anything, they actually need to get the information to read. To do this, they use operating system APIs. When an application uses native controls, it exposes all the needed information through those APIs and a screen reader can get it easily. If an application has it's own GUI toolkit, it's own representation of controls that doesn't correspond to the OS notions of a control and draws on the screen directly, the screen reader doesn't know anything at all. This is the case with i.e. GTK on windows. For a long time, this was also the case with Flash, Java and QT. 4\. screen reader users generally prefer words over symbols (controversial, some might disagree). Symbols are nice for sighted users because they take less space on the screen and are faster to read, but for screen reader users they are not. Lua's "if a less than 1 then print quote this is a test quote end" reads much more naturally than go's "if a less than 1 left brace fmt dot print l n left paren quote this is a test quote right paren right brace". There's a reason why blind programmers like lua and ruby. 5\. Very hard to do right, but one of the most annoying thing for me is to deal with various messages in the console. If it's a web table, you can do two columns, timestamp and message, and a blind user will know it's a table and be able to navigate only in the second column. If it's console output, you can separate them visually, sighted users will just glance over the timestamps but blind users actually need to hear them before hearing the message. Imagine you need to listen through "two tousant eighteen colon eleven colon zero nine seven colon fourty five colon three comma 7520, /cmd/frontend/main.go:19: server started" before each message instead of just "server started". That's the sad reality for most blind people dealing with logs and messages that contain long paths etc. I don't know if that can even be done right without hiding the info alltogether, as it's not possible for a blind person to navigate a table in the console, but this is something that should be taken into consideration.

</comment><comment><USER58> Accessibility is closely tied to portability. As a minimalist its not about what you can add but rather what you can take away and ensuring everybody understands reading the code with minimal effort everywhere.

A more accessible and portable language is one that eliminates overloading and redundancy. Everything in the syntax and expression is deliberate and its not open to various subjective forms of reasoning.

Eliminate white space as syntax. Beauty is subjective, but it isn't necessarily accessible, and it certainly isn't automatically simple. White space as syntax is common in nearly all languages. Even in Java there is white space to separate keywords. White space elimination allows any manner of visual expression and beautification of the language. It also prevents corruption of the code over the wire due to reformatting of corrupting user- agents and OSes that have different line endings. One form of corruption is when a token is shifted, due to different reasoning of line termination, onto a previous line terminated by a line comment.

Eliminate operator overloading. In JavaScript the plus character could mean addition, or string concatenation, or type coercion, or other weird things. The plus character could be a single character operator or the dreaded _++_ which could mean post-increment or pre-increment. In JavaScript the forward slash could mean division or regular expression. For a blind person reading the code as characters or tokens this kind of overloading is unnecessarily confusing bullshit.

Conversely JavaScript has two different syntax forms for assignment. The common form of assigning is using a single equals character. In object literals a colon is used for assignment. This is stupid and looks completely different from the algebra on which equivalent logic is based. Make the colon character the character of all assignment. This leaves the single equals character free for comparisons. If the language imposes a strong/static type system there will be no need for double or triple character comparison operators.

I would invoke a strong/static type system. This allows error detection very early which reduces testing time and jumping between application environments.

I would design the language in such a way that it encourages code in structures. It is easier to follow code when it reads similar to its flow control at execution time. In this regard I would write the syntax such that it encourages containment, nesting, function as organizational models that can be nested, and design everything around primitive data structures.

I am not a fan of OOP programming where the application is easier to write/expand than to debug or read. OOP constructs tend to be convention heavy, keyword heavy, and syntax heavy. Functional/structured languages allow the deliberate organization of its pieces to do much of the heavy lifting as opposed to referenced or logical organizations.

Don't worry about superficial tooling support. Solve the language design problems, the hard problems first. The helpful tooling bits will be easy if you have nailed the hard decisions and produced something with clarity, simplicity, and deliberation.

<comment><USER59> I don't understand what most of these points have to do with accessibility. Why would a blind person have more trouble with the fact that "x + y" might be addition or string concatenation than a sighted person? Why would compile-time type errors be more useful to a disabled person? And so on. It just feels like your opinions on a lot of language design holy wars where disabled people are just as likely to disagree with you as anyone else.

> Don't worry about superficial tooling support. Solve the language design > problems, the hard problems first.

That's mostly what people have been doing for the last most-of-a-century, and it's led to a lot of software being much harder to use for disabled people.

<comment><USER58> The nature of accessibility is in solving universal access problems. It includes blind people but isn't limited to blind people. One of the largest areas of accessibility is solving for cognitive impairments.

The classic example is wheel chair ramps. Who benefits from those? People who have bad knees, people with strollers, people with heavy roller bags. The ramp was installed for wheelchairs but everybody benefits. If the solution were limited only to wheelchairs almost nobody would use it. It would just be in the way and be more of a problem than a solution.

If you are only solving for blindness you don't really understand accessibility and are just in the way.

<comment><USER59> You misunderstood. I only used blindness for the specific example where you used blindness (the only specific example of affecting someone with a disability that you gave; why would that be harder for a blind person?). Most of your points didn't explain how they related to accessibility, they just said your way was easier and better without explaining how or to whom. That's what I was asking.

<comment><USER58> Many people conflate access to aesthetics. There is a difference between actual ease of access and perceived elegancy resultant from vane conditions.

Specifically regarding programming languages the primary concern is parsing, whether that parsing is from software or people reading code.

As a person who has spent 10 years writing language parsers and code beautifiers the vane notions of what a language should look like are highly subjective and not incredibly beneficial. The mechanics and syntax of a language are far more important for understanding what code says very quickly. Like with natural written language elimination of ambiguities and redundant meanings speeds learning and reading which has second and third order consequences for the simplicity of tool design.

</comment></comment></comment></comment></comment><comment><USER60> Avoid Perl 6 and its horrifying Unicode keywords and operators.

<comment><USER61> FUD. Unicode keywords and operators in Perl 6 are __optional __. For each unicode version, an ASCII alternative is also available.</comment></comment>


Ask HN: Are Bad Time Estimates Hurting Software Engineering? - <AUTHOR> Because the more I think about, the more I think many issues with security/performance/whatever would be made better if managers actually trusted their devs to come up with a reasonable timeframe for their work.
I mean, they already trust most professionals to do their job properly in a reasonable time. You don't see managers yelling at construction workers or lawyers or doctors or chefs to hurry up and get everything done faster. Yet apparently it's fine when done to a dev or designer or marketer or what not.
Would things work better if devs were treated like professionals and left to do the work at their own pace? <comment><USER2> I'm a lawyer. I was absolutely pressured to draft and review documents faster than I felt comfortable. At a certain point though your reputational risk (and the reputational risk to your company) needs to be considered above anyone standing over you pressuring you to work so fast that quality is sacrificed.

I can draft a terrible document as quickly as my boss would like but that doesn't add much value and it's not what I'm being paid to accomplish. Management will always be vocal about time and cost while a project is in- process but management and the end user will be far more vocal once the project is complete if the quality does not meet expectations. The time- quality-cost triad is frustrating when you're stuck in the middle for sure but the best approach is to help management understand the trade-offs so you both can set reasonable expectations.

Time is money and all.

</comment><comment><USER3> Bad time estimates hurt anything.

But you are not familiar enough with construction, law, medicine, or cooking if you think they don't have the same pressures (if not worse).

I would say that most of my experience is managers asking for estimates, and developers giving either estimates that are too optimistic or ones that weren't given enough thought.

<comment><USER4> Seems like a chicken and egg problem to me. I ask my developers to give me estimates and then my manager asks me why they're going to take so long (I trust their estimates, my manager is worried about meeting deliverables). There's no way to take that feedback back to the team without it adversely impacting the quality of their estimates going forward. I shield them as best as I can by intercepting requests before it gets to a member of my team, but stuff happens.</comment></comment>


Namib Desert beetle inspires self-filling water bottle - <AUTHOR> http://www.bbc.co.uk/news/technology-20465982

<comment><USER2> Earlier discussion here: <http://news.ycombinator.com/item?id=4815547></comment>


File Destructor: Send trashed files and blame your faulty computer - <AUTHOR> http://www.xnet.se/fd/ <comment><USER2> While I initially thought this was funny- it's incredibly unethical... not that ethics really matters to a growing number of people anymore.</comment>


Ask HN: Vim Pro Tips? - <AUTHOR>

Lots of HN users use Vim, does anybody have an pro-tips for the average Vim user they can share, to help boost everybody's productivity <comment><USER2> Learn to use text objects¹ – they are what makes Vim much more powerful than Vi. You can even add custom text objects² such as function argument³ or camel case word⁴.

Text objects let you operate on logical units of text. E.g. "change inner word" (ciw), "delete a sentence" (das), change inner double quotes (ci"), ...

[1] [http://blog.carbonfive.com/2011/10/17/vim-text-objects- the-d...](http://blog.carbonfive.com/2011/10/17/vim-text-objects-the- definitive-guide/)

[2] <http://vim.wikia.com/wiki/Creating_new_text_objects>

[3] <http://www.vim.org/scripts/script.php?script_id=2699>

[4] <http://www.vim.org/scripts/script.php?script_id=1905>

</comment><comment><USER3> I highly recommend installing Janus, it comes with a bunch of useful customization and plugins: <https://github.com/carlhuda/janus>

<comment><USER4> I recommend avoiding packages like Janus when you are just getting started.

The key to vim success is really understanding the basics. Packages like Janus obscure some of this and hurt truly learning the fundamentals.

Similarly, I would limit plugins entirely. Maybe limit yourself to 1 or 2 new plugins per week until you really get understand whats going on.</comment></comment>