So I've been looking at furthering my knowledge into embedded and lower level hardware programming, however, every time I look for jobs that mentions "embedded" it's always high level stuff. To me, that doesn't make a whole lot of sense.

So what exactly does "embedded" entail? When I think of embedded I think of lower-level microcontroller programming and such. If embedded is not the proper title for this, then what should I be searching for?


Define what you mean by higher level stuff. Writing drivers and any other type of software that communicates with hardware is probably what most people think of when you mention embedded software. While that is part of it, that is only a small part. Once you have all that setup there is still the whole application to write that probably never actually talks to the hardware directly and more than likely in most cases this is the majority of the development effort. This can at some level be comparable to "higher" level programing. However, in the embedded world you are probably working under some constraints especially in terms of computational power and memory. Here is list of thing that I think about on daily basis that probably have less importance in higher level development in most cases.

  • Thread concurrency (both protection and timing)
  • Memory allocation and deallocation and usage
  • Heap management (avoiding fragmentation)
  • Meeting real time deadlines
  • Thread prioritization
  • I/0 performance
  • DMA transfers
  • Stack Sizes
  • Library performance
  • Language features (exceptions bloat your code)

Also, embedded platforms tend to be highly specialized to accomplish one specific goal opposed to a PC that is designed to be a platform for general heterogeneousness computing. This mean that you probably have a lot of custom code that may or may not be portable.


From Wikipedia/Embedded System:

An embedded system is a computer system designed to perform one or a few dedicated functions often with real-time computing constraints.

In short, the term can apply to any sort of system which is not a general-purpose PC. This can range from simple microcontrollers to Networking hardware to modern Gaming Consoles.

If you consider "high level stuff" to mean "uses a high-level programming language" or even "is a large object-oriented project," then of course it's always possible that you can have very high-level software on an embedded system.

Generally, by specifying that your software is going to be on an "Embedded" system, you mean that in some way your software is going to be coupled to the embedded system--and maybe not be highly portable.

It's a very broad term, indeed. Some things I would not expect to hear called "Embedded" would be PC software, web applications, and Server Software in general. There is certainly no guarantee that Embedded software will exclude any sorts of high level programming or design, though.

  • Additionally I might point out that the purpose of specifying that your software is embedded is to signify that you will have less libraries and existing solutions available to build your solution from. – ProdigySim Apr 4 '11 at 22:09
  • +1. Common examples for embedded systems are the computers in POS or ATM machines. Even if they run off-the-shelf OSs like Windows or Linux. – nikie Apr 5 '11 at 7:37

I suspect you're looking at jobs where "embedded" means "computer in a box", generally one that does one specific task. Quite likely running most of a Linux distro or a Microsoft OS, but it will be fairly complete and you'll be able to use standard GUI IDEs and so on. The embedded part really comes when the device ships out as a multi-channel video recorder, media streaming device or burglar alarm.

These days you can do a lot of processing in a 1W device, so the definition of embedded has grown accordingly. But even 20 years ago we had battery powered embedded devices running fairly standard DOS and built programs for them using the IDE of the day (Symbol barcode scanners had libraries for C and Pascal, for example, so we used Turbo Pascal on Win3.1 to build the executables). But we also shipped "industrial PCs" that booted DOS then our software, and the input was limited to a few big waterproof buttons mounted on a stainless steel box. The 15" LCD behind glass in that box meant we had lots of output options, but attaching a keyboard meant opening the box (inside a food factory). Those might be considered embedded from some perspectives. Mostly that the user had few error recovery options - power cycle it or not.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy