Earlier quoted context omitted.
Handmade GUIs, frameworks drawing on canvas instead of using DOM, and abominations like VNC over web instead of normal desktop apps seem to be the new accessibility plague. We're pretty much done with Flash and Java on the desktop, QT isn't that bad any more, accessibility-wise, but this kind of stuff is now becoming more and more popular. I've heard of systems that promise you better utilization of your licensing re…
Not everything needs to prioritize accessibility. This page is mostly tools for video games which typically have no accessibility. I think you may be bringing a pet concern into an area that isn't relevant.
Handmade: A Community for Self-Rolled Performant Software (2016)
61–70 of 96 posts
Re: Handmade: A Community for Self-Rolled Performant Software (2016)
#62Earlier quoted context omitted.
> Electron is the opposite of the 'handmade philosophy', but is still not accessible. On the contrary, Chromium probably has the single most mature and robust implementation of accessibility APIs across platforms. It's true that not all Electron apps are accessible, but it's way easier to make an Electron app accessible than to make a handmade GUI accessible.
Yeah, ok, but the problem is the same: even though accessibility APIs might be provided (this time by Electron, not the OS), applications don't make use of them.
Re: Handmade: A Community for Self-Rolled Performant Software (2016)
#63Earlier quoted context omitted.
A lot of VST/AU plugins already use Qt, JUCE or SynthMaker for the GUI and are completely inaccessible. On the other hand, there are a lot of web pages and Electron apps that are completely inaccessible as well, despite using accessibility-ready web tech. The problem is not really the lack of an abstraction layer, but more the fact that those developers are doing a shitload of work to make something look über cool an…
No disagreement there. Still, there are also developers who go out of their way to make their software both cool-looking and lean and mean by rolling their own GUI toolkit... and now it would take them way longer to implement accessibility.
Re: Handmade: A Community for Self-Rolled Performant Software (2016)
#64The Handmade metaphor masks a key difference between software and physical goods. IIUC, mass-produced physical goods are inferior to their handmade counterparts because of the trade-offs that enable profitable mass production. So we have a strong emotional attachment to handmade things being better, and the Handmade movement plays on that emotional attachment. But the metaphor breaks down if you think about it. A car…
It could be written for one person and mass-distributed with the understanding that you are using software written for Bob's needs.
>I'll just add here that it's precisely the economics of large-scale software distribution that allow concerns such as internationalization and accessibility to be addressed, while a solo Handmade project will probably not have these important things.
You have mixed up cause and effect here. Internationalization is a concern caused by mass distribution, not an existing concern not being addressed. The same goes for accessibility. Handmade software will meet the accessibility needs of the one person it is written for. Have different accessibility needs? That is a different piece.
Re: Handmade: A Community for Self-Rolled Performant Software (2016)
#65What people don't realize is that modern, high-level languages and abstractions give you much more than just speed of development. If you use a garbage collector, you don't have to do manual memory management, which is amazing for security. You also don't need to worry about buffer overflows and weird pointer exploits. If you use web tech, you get a lot of important stuff, like sandboxing, handling of esoteric keyboa…
A pedantic point, buffer overflow protection and the GC are separate things. Buffer overflow protection is bounds checking, GC's are ensuring memory that is no longer in use is reclaimed. But the boundaries on the programs you mention, are more to do with the system not allowing these actions than the language. Also, there are other ways to achieve memory safety for all but maybe a few cases without a GC. One being r…
What they're pretty good at is solving for use after free. Even there, caveats apply (see widely documented thread safety fiasco of shared_ptr).
Re: Handmade: A Community for Self-Rolled Performant Software (2016)
#66Earlier quoted context omitted.
> If you go the handcrafted, lightweight and fast route, you're sacrificing a lot of features, possibly without even being aware of what you lose until it's too late. The notion that an engineer signing on to make high-performance software in 2020 doesn't know what they're "sacrificing" is a little unreasonable. Conversely, it seems unlikely most people developing the kind of software you're advocating for understand…
You make good points. And I do think miki123211 is conflating memory safety with GC. But the concerns about Handmade software lacking important user-facing things like accessibility and internationalization are real. TO take one particularly ironic example, lots of tools in the field of audio production roll their own GUIs, and invariably, these UIs are completely inaccessible to screen reader users. I say this is ir…
This is a debate/discussion I've been having for 20+ years now (as the original author of Ardour).
The GUI of a typical DAW (or even a moderately sophisticated plugin) serves as memory aide for sighted users. 48 tracks? Which ones did I mute? A sighted user doesn't have to remember - they can just look.
Sight-impaired/blind users of older hardware mixing consoles use the tactile experience of those devices to partially fulfill the same role, which is why modern full digital consoles with tap-only-LED-lit buttons are so much harder for them to use: they have to either remember or investigate which features are enabled and which are not.
In addition, most DAW and many plugin GUIs present information in ways that are more or less inconceivable for screen reader presentation. Waveforms are the obvious example, although here perhaps sight-impaired users have what some would consider an advantage, in that they are forced to work entirely by ear, rather than use on-screen representations that have only a debatable relationship with the sound.
But routing presents another area where it can be very difficult to present the current state in a way that could ever be rendered meaningful by a screen reader.
Please don't think that I don't view accessibility or i18n as of critical importance - I absolutely do. But I also think that when application niches (like audio production) evolve their own highly-developed visual language to supplement and assist (sighted) users, that the correct/better answer for sight-impaired users may be non-graphical applications rather than trying to figure out to how speech-render the graphical representation.
This is one area in which Linux is far ahead of Windows and macOS: there are numerous command line applications available for audio production which would strike utter fear into the hearts of most sighted users, but that turn out to be incredibly great for sight-impaired users. Ecasound, I'm looking at you (among others).
Re: Handmade: A Community for Self-Rolled Performant Software (2016)
#67What people don't realize is that modern, high-level languages and abstractions give you much more than just speed of development. If you use a garbage collector, you don't have to do manual memory management, which is amazing for security. You also don't need to worry about buffer overflows and weird pointer exploits. If you use web tech, you get a lot of important stuff, like sandboxing, handling of esoteric keyboa…
Re: Handmade: A Community for Self-Rolled Performant Software (2016)
#68What people don't realize is that modern, high-level languages and abstractions give you much more than just speed of development. If you use a garbage collector, you don't have to do manual memory management, which is amazing for security. You also don't need to worry about buffer overflows and weird pointer exploits. If you use web tech, you get a lot of important stuff, like sandboxing, handling of esoteric keyboa…
If you want the advantages of the garbage collector but the power of native there are languages like D, Go, Rust, Objective-C, Swift. If you want an "extremely fast, small and lightweight GUI framework" that also handles esoteric keyboards, RTL languages, screen reader accessibility and other things you can use your OSs native controls. I bet most naïve (and native) Cocoa/Win32 app will give you 100x better keyboard…
That may be true for Cocoa, but it actually isn't for Win32. It takes work to make keyboard navigation work correctly in Win32, unless you're using a dialog with nothing but standard controls (note: dialog means something specific in Win32). Windows Forms helps with this. Also, as soon as you depart from the stock Win32 controls, you have to implement the UI Automation accessibility API entirely on your own, and that's not an easy task even for a single custom control. So there are actually good reasons why Win32 isn't a good choice for new projects.
There's another reason why web applications tend to be more navigable with third-party Windows screen readers than native applications. For the mainstream web rendering engines, third-party screen readers enable a sort of virtual cursor that let's the user navigate the DOM in a linear way by pressing the up and down arrow keys. This makes it straightforward to navigate to anything in the document, even if the application itself doesn't implement keyboard navigation. Now, this same navigation model could just as well be applied to native applications, and the Narrator screen reader built into Windows actually does offer that option. The fact that third-party screen readers restrict that option to web content is arguably a deficiency, but one that developers who care about accessibility should consider when targeting Windows today.
Disclosure: I work for Microsoft on the Windows accessibility team, primarily on UI Automation and Narrator. These are my own opinions though.
Re: Handmade: A Community for Self-Rolled Performant Software (2016)
#69Earlier quoted context omitted.
A lot of VST/AU plugins already use Qt, JUCE or SynthMaker for the GUI and are completely inaccessible. On the other hand, there are a lot of web pages and Electron apps that are completely inaccessible as well, despite using accessibility-ready web tech. The problem is not really the lack of an abstraction layer, but more the fact that those developers are doing a shitload of work to make something look über cool an…
No disagreement there. Still, there are also developers who go out of their way to make their software both cool-looking and lean and mean by rolling their own GUI toolkit... and now it would take them way longer to implement accessibility.
And by the way, to keep on topic, "handmade" audio software people are not really creating their own GUI toolkit. That's the big boys at Waves, Native Instruments, IK Multimedia, etc.
The problem to me is that people are trying to make things that look exactly the same everywhere with complete disregard for both the user and the particularities of each platform.
And by platform I don't just mean the OS: one of my pet peeves with audio software are plugins that skip the DAW's preset saving and implement their own. The walked an extra mile only to give me a shitty interface when I wish I could just use Logic presets or whatever.
Re: Handmade: A Community for Self-Rolled Performant Software (2016)
#70Earlier quoted context omitted.
You make good points. And I do think miki123211 is conflating memory safety with GC. But the concerns about Handmade software lacking important user-facing things like accessibility and internationalization are real. TO take one particularly ironic example, lots of tools in the field of audio production roll their own GUIs, and invariably, these UIs are completely inaccessible to screen reader users. I say this is ir…
There are much deeper and more sophisticated reasons why inaccessibility to screen readers is not really the core of why we should consider audio production software to be inaccessible. This is a debate/discussion I've been having for 20+ years now (as the original author of Ardour). The GUI of a typical DAW (or even a moderately sophisticated plugin) serves as memory aide for sighted users. 48 tracks? Which ones did…
> the correct/better answer for sight-impaired users may be non-graphical applications rather than trying to figure out to how speech-render the graphical representation.
This cuts to the heart of a long-standing debate among accessibility advocates and blind techies. It's true that tools tailored specifically for blind people can be more productive and easier to use. But they can also isolate the blind community from the sighted mainstream. For example, would a DAW developed specifically for blind people enable them to collaborate with sighted peers, or to use one-of-a-kind plugins that are developed for mainstream DAWs with a visual interface? This is why, while retrofitting accessibility onto a GUI is often suboptimal, it's necessary.