I’m a huge DIY’er. I don’t like to buy things when I can build them myself. But honestly, that doesn’t always end up in the optimal allocation of my time, when viewed from a getting-stuff-done perspective. Sometimes, if you’ve got a bigger project in mind, the right way is the quick way, and the quick way is buying something that already works. But when that something is itself not hackable, you’d better be darn sure that it does what you need, and what you could reasonably expect to need in the future, out of the box. And that’s where extensibility comes in.
It’s rare to find products out there that are designed to be both easy to use for the newbie, but extensible for the advanced user. For one, it’s hard work to tick either one of these boxes alone, so it’s twice as hard to nail both. But my other sinking suspicion is that designers tend to have an end user in mind, and maybe only one end user, and that’s the problem. When designing for the newbie, convenience is king. Or if targeting the pro, you maximize flexibility, but perhaps at the expense of designed-in complexity.
There’s a way out, a cheat code, if you will. And that’s making the project open source. Go ahead and hide the complexity from the new user if you want — as long as the pro is able to dive into the schematics or the source code, she’ll figure out how to extend it herself. Openness frees the designers up to worry about making it easy to use, without compromising its flexibility.
I think that this blend of easy and extensible, through openness, is what fundamentally drove the success of Arduino. On the surface layer, there are libraries that just do what you want and drop-down menus with examples to access them. But when you needed to actually use the chip’s hardware peripherals directly, there was nothing stopping you. For the community at large, the fact that all of the code was openly available meant that extending the base was easy — and let’s not beat around the bush, the community’s libraries, tutorials, and example projects are the real reason for the success of the platform.
Look around you, and look out when you’re making that next non-DIY shortcut purchase. Is it easy to use? Can you make it do the things that it doesn’t yet do? Just two simple requirements, yet they seem to knock out so many products if you want both. Then look at those that are both simple and flexible — are they also open? At least in my little world, the answer is almost always “yes”.
“Simple things should be simple. Complex things should be possible.”
– Alan Kay (while working at PARC)
I prefer: “Allow for the edge cases, but optimise for the common cases”
Talking about it in terms of complexity like that can be misleading. Every problem is complex of you look at it in enough detail. The question is where to put that complexity. If you’re wanting to present it as simple, then the aim is to hide that complexity. The more simple you want something to feel, the more complex the system needs to become to achieve that.
Unfortunately, many people in the tech industry see “simple” as meaning a simple implementation. That’s not removing complexity – it’s just moving it outside of the implementation, kicking the can down the road for someone else to deal with it.
I was glad to see this article acknowledges that.
Though I think it should be said that making something open increases the complexity. It benefits from that added complexity, but it’s a tradeoff. And after a career of working in open source it’s something that I wish more people were conscious of & acknowledged. And were kinder about.
“Allow for the boundary cases…” so us older folks know what you are saying, if that is what you are saying.
One of the fascinating things about DIYers and YouTube is the number of people who use a basic machine tool to make improvements and fixtures and extensions to said tool by using the tool! Beginners and early enthusiasts rarely understand how much time is spent on fixtures, setups, and special dinguses in order to make something. The same goes for firmware/hardware development.
I encourage HaD to show more of this aspect than “powered by an Arduino”.
We didn’t do this due diligence, before we bought our Cricut plotter. I kind of expected, that there will be opensource drivers for it. Now, we are stuck, with their shitty software. Which is shame, as the hardware is really great.
It’s really a shame that it’s so common for hardware designers to release such awful drivers/software for their thing, to the point that it completely ruins the experience. Hardware developers need to understand that the software is just as important as the hardware. Also, I don’t really understand why hardware developers don’t just release their drivers as open source, because they’re not selling the driver, they’re selling the hardware, so it doesn’t make a difference in terms of money. (probably to hide how shit their code is)
If they outsource the firmware/driver development (which hardware dedicated engineers often do)..
Then the driver comes with whatever this sketchy firmware house decides is a license, and they are often extremely proprietary, all the while using their own dependency on open source cose
This might do the job; https://sourceforge.net/projects/licut/
Arduino is the perfect example of “jack of all trades, master of none”.
One often doesn’t need a master, but it’s current to need many trades. When not the case, search for a master.
What is the thumbnail image? Looks like a hightech version of one of those old toys that took the shape of whatever you pressed it against.
It looks like a Lite Brite.
https://letgrow.org/wp-content/uploads/2020/11/lite-brite-main-image.jpg
I can even give an example outside of computing! My cheap beginner roller skates don’t have changeable wheels, insoles, or trucks. That’s not very extensible, but they were excellent to learn on. Now I’m using a custom set I cobbled together out of spare parts in an old skate shop. That’s the open source nature of the design in that tons of different parts are compatible across brands and decades. Shame no one makes my bearings tho
“I’m a huge DIY’er.”
We know you are huge, but you DIY too?
B^)
“as long as the pro is able to dive into the schematics or the source code, she’ll figure out how to extend it herself.”
No, just no! Open Source is great but you’re advocating not using it right.
Being able to customize the code one uses is awesome. But that is no excuse to dumb down a project to the point that all but the simplest of users have to resort to modifying source code to get it to do what they want or need.
The biggest problem with this sort of thinking is it is so short sighted. Does your advanced user ever update? Do they have to keep re-applying their hack to get around your purposeful crippling every time you release a new version? Do they just stick with that old version they customized till the end of time, new features, security problems and compatibility with new formats be-damned?
Open Source is good when a user can code a missing feature and send that code back to the author who then includes it in future releases making the maintenance task of re-porting it to new versions non-existent. It’s not useful as an excuse to lobotomize everything just to make the computer illiterate and the one-button Apple minded simple-ui zombies happy.
Go ahead and hide your “advanced” features behind an “advanced” menu. But don’t use Open Source as an excuse to over-simplify and cripple your UI!
Insightful. This is key.
(golf clap)