Why do engineers (love to) hate Arduino?

Engineers love or hate Arduino, but why?

why engineers hate arduino

A couple of months ago podcast I listen to interviewed an embedded engineer. Eventually, the topic of Arduino came up, and all three people on the show let of sighs of disgust. This lead to me to start thinking about why do engineers hate Arduino?

On this particular show, they said Arduino had too many abstraction layers to be useful. All three members of the panel agreed that direct hardware access was critical to success in embedded designs.

On the same episode, the same people talking, the topic changed to using a new chip or sensor. Then this comment was made: “I won’t design for a chip with no high-level software API and detailed examples.” (I’m paraphrasing to protect the innocent.) Everyone on the episode agreed.

Wow. Just what is Arduino then? One view is that it’s a well-documented board, with a high-level API, and lots of detailed examples. But somehow, these features on other platforms is desirable? So why do did these engineers hate Arduino so much when it is what they said every vendor should offer?

Are they haters? Are they trolls? Or are they just engineers who show a behavior common to humans. Let’s take a look at why engineers hate Arduino using other examples and concepts from psychology.

1. It’s too Easy

Recently I got to see three of the Arduino co-founders speak at Berkeley. One of my favorite quotes was from Tom Igoe:

And this is where most engineers, especially embedded engineers, take umbrage with Arduino. It makes the world of electronics and microcontrollers ridiculously simple to access. Of course, you might be thinking, but isn’t that a good thing? And if you ask those same engineers they would likely agree.

Arduino-hatred is hardly the first example of experienced engineers disliking non-technical users as a field expands.

Remember AOL?

One of the passages that resonated with me in Walter Isaacson’s book “Innovators” (my review here) revolved around when AOL users started using the Internet.

Veterans of the Internet and fledgling World Wide Web were disgusted by the flood of uninvited users. These new users didn’t understand proper etiquette, they asked ridiculous questions, and most of them didn’t even know what an IP Address was!

Here’s what I find interesting. Do people whose first access to the internet is a smartphone, know any more or less than AOL users did back in 1993? Probably not. And there is a lot more of them. We don’t see as much backlash against these neophyte users today.

Analog vs Digital

On Episode #103 of The Engineering Commons Podcast, the team interviews Dave Vandenbout. Dave gave a recount of his experience when digital electronics engineering was in its infancy. He recalls that “analog engineers” (were there others at the time?) referred to the digital engineers as “digital dingbats.”

Why? One of the reasons is that digital engineers, especially new-to-electronics digital engineers, didn’t have the base of knowledge the “old-hat” analog guys had. From the experienced engineer’s point of view, these darn kids don’t understand the details of hooking up 7400LS chips together!

And you know what, those darn kids didn’t need to understand 20 years of analog design to make the AND-gates work. Of course, being able to dig deeper is critical when circuits “don’t work” but that’s a topic for another rant.

2. It isn’t ideal (for everything)

When you have a hammer, everything looks like a nail. Many Arduino users aren’t looking for the ideal solution. They are happy hammering a screw into the wall if it solves their problem.

Most people are familiar with the concept of confirmation bias. (In America it becomes the lifeblood of social media during election times!) In short, confirmation bias is focusing on elements that support a preconception.

An example I experienced was when I wrote about the performance difference between digitalWrite and direct port manipulation. The actual point of the article was to show how to make measurements on a Logic Analyzer. One Twitter (ex-)follower responded un-politely about Arduino users, stating they couldn’t see past the “horrible and garbage API.”

There is an element of truth there. Some users cannot see past the API. They’re new. Of course, they can’t. Not yet! In this case, the rude Twitter comment was someone who used confirmation bias, digitalWrite is slow, to support their negativity.

Here’s the thing, though, if digitalWrite() works, it is perfectly acceptable to use it as-is. As Donald Knuth said,

“…premature optimization is the root of all evil (or at least most of it)…”

In other words, even if a solution isn’t optimal to a problem, it may not be necessary to “optimize” to a better one.

3. It’s too popular

People love to hate popularity, which leads to Kathy Sierra’s idea of the Kool-Aid Point.

Physics of Passion

Physics of Passion

Sierra is a developer that taught Javascript-based classes. Javascript is another technology engineers, software engineers, love to hate. Sierra makes the point that the existence of a passionate group means you also create passionate haters (she says “detractors.”)

This concept isn’t some new-age touchy-feely idea. It is how humans behave. Humanity naturally polarize around almost any idea or object.

Nothing makes everyone happy.

Her point boils down to the idea if a group hates you, then you’re doing it right. But what about engineers? Surely engineers are logical people who only make rational evaluations. Logically, they would never hate something that has positive attributes, right?

And so, part of why engineers hate Arduino is that it is the popular thing to love or hate. I’m sure programming languages, smartphones, operating systems, and cars are immune from this effect.

Don’t feed the haters

When you meet someone who demonstrates the behaviors outlined in this post, you might wonder what you should do. If that person is unable to revise their beliefs based on the new evidence being presented to them, they suffer from conservative bias. It’s probably better to just let things go.

Otherwise, you are going to find yourself in the middle of a full-force flame war. The irony? Both you and the other party will think each other are trolls. And in a way, you both are trolls.

You have both drank Kathy Sierra’s Kool-Aid.

Long comments, URLs, and code tend to get flagged for spam moderation. No need to resubmit.

ALL comments submitted with fake or throw-away services are deleted, regardless of content.

Don't be a dweeb.

Leave a comment

33 thoughts on “Why do engineers (love to) hate Arduino?

  1. For me, I don’t _hate_ Arduino, but I find it to be very limiting in more advanced applications, especially when you need to directly access the registers on the chip or need to use the ADC in a way that isn’t supported by the Arduino environment. The programming environment also makes it very hard to organize code when working on highly complex projects – in situations where you have a large number of functions it’s often better to split the source code into multiple custom includes, something that most IDE (such as Atmel Studio) have no issue with but the Arduino IDE is only capable of doing if you dump your includes into the default library directory. It also doesn’t help that as soon as you start having to utilize those more advanced functions of the Atmel AVR series chips you have to learn an entire new C++ library, as the Arduino environment uses its own simplified C++ library rather than the one generally used by Atmel microcontrollers.

    In short, Arduino is a good starting place and great for simple applications, but it doesn’t grow very well and more advanced users, such as engineers, often find themselves limited by the platform’s “user-friendly at the expense of functionality” design. That’s not to say it’s a bad platform, just that it has its strengths and weaknesses.

    What I do hate, however, is when someone sticks an Arduino into a device that only needs a simple relay, such as a basic alternating station setup for a model railroad layout. I like to refer to things like that as “Arduino for Blog Cred” projects, because they don’t need a microcontroller to work, the person working on that project just tossed one in because it’s shiny and attracts attention.

  2. Arduino has enabled tens of thousands of design, product development and architecture students in our country to experiment with physical computing and then realise tangible ideas, some that subsequently won awards ore were later taken up by industry and developed further.

    The arrogant and condescending attitude of certain commenters here is outrageous and shows what is so terribly wrong with society.

  3. Arduino is subpar and expensive. The pricepoint per compute is not comparable. A “real” engineer would use the atmega chip and design a custom pcb, or use a pic chip or an fpga. pre made arduino boards aren’t engineering devices, they are learning tools. Breakout the microprocessor and then maybe. Otherwise you’re just paying for shit you don’t need. Even with an ESP32 or a teensy. C’mon now. It’s not hating at all just common sense.

    • I am not sure I understand your argument. “Arduino” is not really a board, it’s more the software libraries surrounding it (the abstractions mentioned in the article above). A “real” engineer does not have to buy an expensive Arduino board for the final product, he just has to buy a ATmega328p/ESP32/(whatever MCU he is interested in) chip and make a PCB based on that. The “using arduino” part is just about which bootloader and code you put on the microprocessor. It costs exactly the same to use arduino or not. The difference is that with Arduino libraries, you can write your code much faster and make your product do more complex thing easier, at the cost of having a slightly less efficient code. Whether your application needs maximal performance and thus lower-level code or not, should be the main deciding factor.

      I am myself using ATmega328P chips (without a board) directly on a breadboard/PCB and program it using arduino bootloader and libraries.

  4. Sometimes is not a love/hate with Arduino, is more about when to and when not to, or best not to use. Sometimes a function is just simple enough that is much cheaper and easier for hardware type folks to build than program, and many times the Audrino is more costly do do these simple functions, I still design is standard logic many times. But is great regardless if just want to, learn, etc. I dont think there is a wrong or write answer. Many do not have the electronics background to do a more complex logic design, or at least get to building them practically. so programming and ready made kits are much easier then. But then I sometimes find myself frustrated when searching some info and all I see is Audrino related projects and hard to find the old school way of doing something. 🙁

  5. Thanks for this article. I have no issue with the Arduino and am in favor of it as an introductory learning platform.

    My issue is with the use of the expression “drinking the kool-aid”. Those of us who were around in the seventies know that this is a reference to the 1978 Jonestown Massacre when the cult leader Jim Jones persuade some followers and forced other followers to commit suicide by drinking cyanide laced kool-aid. Over 900 people died.

    It is a horrible expression.

  6. Arduino makes it possible, not to mention way cheaper to prototype concepts – its like the hatred against the BASIC language by C++ developers – sure C++ unlocks many things not posdible with VB – but far more projects actually get implemented because of VB – I’ve worked on a few C++ projects that failed to deliver, or went way over budget because it is a way longer development process. And of course there is the old adage that a bad tradesman blames his tools – its just as easy to implement clean arduino design as much as totally flawed designs, bad programming, etc.

  7. An excellent topic.

    Microcontrollers, photography, music, literature, urban fashion or product design – whenever curious and open minded people (professionals like to brand those people “amateurs”, “laypeople” or worse) happily and care-free enter a field previously played on exclusively by a small elite (the often highly paid “experts”), the elite suffers what psychologists call a narcissist blow, for their previously secret knowledge and system of belonging develops cracks that eventually can no longer be papered over, no matter how hard they try.

    I endure such backward-looking yesteryear discussions at conferences in my field, where the old guard desperately tries to defend their holier-than-though realm only to discover in horror, that in today’s connected and globalised world, the above mentioned curious and open minded people give a damn about proto-religious attitudes – and just start thinking, making and doing without asking the experts for permission.

    As for Arduino and its derivatives, any technology that enables common citizen to take matters in their own hands and explore what was previously under control of experts has my blessing.

  8. I probably embody the whole love/hate thing in one person, and have spent a LOT of time working with Arduinos and thinking about this. I can’t speak to a lot of the “irrational” hate that you point out, but I think I can trace where a lot of the genuine problems come from: The Arduino IDE, and their focus on Pedagogy. (What people call the “Too many layers of abstraction” issue comes from here.)

    In general, the Arduino hardware is very nice. Well built, no major flaws, easy to work with and quite hardy. Unfortunately the IDE is a mess, and barely fit-for-purpose. They forgot Einstein’s maxim “Things should be as simple as possible, but no simpler.” Things are better now, in some ways, but also worse in others, because they’re addressing (at a very late stage) issues they really should have thought about back in the beginning, like libraries.

    Basically, the Arduino IDE was never designed for programs longer than about 100 lines. It doesn’t even _show_ line numbers unless you turn that on. It’s library management is awful. What that means is you have a nice easy learning curve for the first few months, and then you hit a wall.

    The digitalWrite() function pretty much encapsulates the whole issue. It’s easy, it’s slow, and using it increases binary sizes far more than is reasonable. Everyone knows it. Every “major” project (Marlin, GRBL, etc) ends up writing their own macros out of sheer necessity, and so instead of “simplifying” the environment you end up with some code using the functions, some using the macros, and the extra complexity of the interactions between them. Code isn’t portable between projects. It’s insane.

    People can’t “graduate” from Easy Arduino to Advanced Arduino without basically falling off the learning curve, and having to start over on a new one, wasting all their time and effort up until that point. “Oh, it’s just a learning experience, we didn’t expect you to do anything _serious_ with it” is another way of saying “We sell crap to kids because they don’t know any better.” and that’s when I start grinding my teeth.

    Another example: You can’t use the IDE to upload binaries. Again, that’s fine if you assume you’re only dealing with 100-line programs hacked together in an afternoon, or copypasta’d from the Arduino Playground (and “playground” is an excellent description) but when you’re trying to distribute firmware intended to drive 3D printers (like Marlin) that’s simply not good enough. People’s safety depends on that firmware. Forcing everyone to recompile it from scratch (instead of an “App store” with binaries) means they’re at the mercy of whatever API or library changes happened that week. Critical timing loops are vulnerable.

    A lot of people’s first experience with the IDE isn’t in the classroom, it’s trying to download and install existing projects to the hardware they bought just for that purpose. And the forums are full of suffering people who can’t get it to work. There’s no dependency tree that can pull in the right libraries for each project, there’s no ability to have multiple versions of a library installed for different projects.

    If the IDE had a way to build binaries for a set of common targets, it would vastly improve the process of distributing software (and all the effort people have put in) as well as give devs confidence their code is actually going to work cross-platform. That’s the messy truth of software development, and ignoring it doesn’t make it go away.

    There was a major issue not long ago because the API used to use the digitalWrite() function to set the pullup state if the pinMode() was set to INPUT, because someone thought that would be “easier”. But by overloading that function with a semantically inappropriate side-effect, they created a situation where they can’t even issue compiler warnings after the API change to indicate they just broke your code, because you originally did it the way they told you.

    There’s no directory structure in projects that encourages re-use (yet). You can’t even write libraries FOR their IDE, USING their IDE.

    It’s bad software engineering. It’s bad computer science. It’s a denial of the realities of what it takes to build stable systems, not compared to the “olden days”, but modern best practice. Kids are being led down the garden path to the “Playground” and then left there, and then the rest of us have to pick up the pieces when they want to start contributing to important projects.

    That’s my issue, anyway. But it is nice hardware.

    • You might have provided the most articulated response I have ever had on this subject. (My post was the result of multiple discussions with people.) I appreciate you taking the time to respond. And I apologize it got caught in the spam filter! It is the longest comment anyone has ever posted here… 😉

    • Hi,

      Good points in both article and this reply. I would just add my views in hopes it would allow experienced people to see whats cooking in mind of a hobbyist.

      Being just a hobbyist, all I wanted to make was a digital thermometer for my room 😛 and that’s what got me introduced to arduino.

      Even with no background in embedded systems, arduino was very easy to start, I wrote 900 lines of code for thermometer, dancing lights and temperature based fan controls, that much easier it is, for new user.

      I tried to get in raw coding and it was a mess. I dont want to learn things from abacus, to make the registers work, I just want them to work. As its said, people dont want drills, they want hole.

      After half a dozen projects, I am looking for this topic because I discovered that STM32 offers much more than atmega328 and I want to utilize it. But after googling and seeing the messy crowd of one bricks castles of ways, as a hobbyist Arduino with its limitations, still is a lot unified.

  9. I see it the same way as fixing my own car. I’m not a professional mechanic but that doesn’t stop me from learning to do relatively simple stuff on my own. That doesn’t mean I’m capable of fixing any problem on any car.

    I am a hardware/firmware engineer who doesn’t see these platforms as a threat, and neither do any of the hardware or firmware folks here where I work. Some people may feel threatened, meh…I’m not sure that it’s as big an issue as it’s made out to be here.

    Platforms like arduinos are great to leverage for certain purposes such as a quick prototype, a debug board to test a product with, a proof of concept or a even a personal DIY doodad not for commercial use. But that doesn’t mean Arduino is a solution to every problem. A bunch of things have to be considered to make a product usable (that’s what’s learnt in school), and Arduino may not have the right mix of features for a product design. Lord knows there’s a lot of easy-to-use platforms to choose from nowadays (think Beaglebone or ESP32) that have a different mix.

    I like the Arduinos of this world because they force all the other chip manufacturers to invest resources in developing a richer and more accessible development ecosystem for their own eval boards…the bar has been raised, we all win.

  10. I have a PhD in Electronics Engineering from Georgia Tech. I work extensively on wearable electronics (analog and digital) and have worked with Arduino systems as well as other embedded systems that are more difficult to use. For most devices we develop, Arduino just does not cut it. The DIY tricks and instructions that are widely avaliable also do not cut it at for the circuits we design. Arduino systems consume a lot of power and do not have enough processing capabilities. So yes, I am not too fond of Arduinos for my own development purposes.