Not necessarily agreeing or disagreeing with colleagues, I'd rather go by another line: it depends.
Depends on the type of application you want to do. Essentially, as already mentioned, the compiler must translate from the
C language to the target target instruction set, regardless of the architecture used. If you use compilers that support the
ANSI C pattern (as
gcc ), the language
C itself and the
POSIX functions can be written perhaps, without any difference between the platforms.
But in addition to the set of instructions, there are other differences between desktop x86 (which I'm assuming you have experience) and a
ARM architecture. I will also assume that in both cases you use Linux:
- Embedded hardware : The hardware available for processing is more limited: you have less primary memory and less "processing power."
Peripherals : Basic peripherals, such as USB, should be used in the same way on both platforms, since it is the function of the OS and modules to deal with them and provide APIs for the programmer. But you may need to access some other peripheral on a low-level access (such as using an SPI or I2C protocol - which is very common in an embedded system), and this should be different on an ARM platform than an x86 platform.
Energy Consumption : Depending on the product you are going to do, you should excel at meeting some power consumption requirement.
Graphics Acceleration : A very different feature of an ARM system for a traditional PC is graphic acceleration. Generally on ARM systems only OpenGLES (Embedded System ES) is available. OpenGLES is different from traditional OpenGL. Writing an application that uses graphical acceleration for ARM is certainly different than writing one for an x86 PC.
APIs, libraries, and other software : You should be aware of and do a survey of the external libraries and software and APIs you will use, they work correctly on the device you are going to use.
In general, in my experience, these are the characteristics that most differentiate systems. The difference, in my opinion, goes beyond the set of instructions of the processors: although the software abstractions try to hide the architecture of the system and leave everything "transparent" to the programmer via the same APIs, the "ecosystem" that involves ARM is different from x86. I never needed to care about the instruction set itself. If you do not need to make an ultra-optimized application for this platform, you should not have to care about the instruction set either.
@AlexandreMarcondes recalled in the comments on endianess different from both platforms. In his words:
It also has the issue of memory access (little endian and big endian), also called endianess. This is the order that the platform (processor) stores numbers larger than 1 byte, whether or not there is order inversion
Knowing endianess is really important for C programming especially if the programmer uses
in its code or if it transmits data to other peripherals or devices over the network.