Best computer hardware embedded systems books according to redditors
We found 89 Reddit comments discussing the best computer hardware embedded systems books. We ranked the 28 resulting products by number of redditors who mentioned them. Here are the top 20.
If you want something really hardcore check out The Design and implementation of the FreeBSD operating system
Edit for 2nd edition
Although old, this book does a very good job explaining the Android architecture https://www.amazon.com/Embedded-Android-Porting-Extending-Customizing/dp/1449308295
Given it was written for Android 4, it doesn't have all the new Treble staff (the basis are still the same, so I think it's still worth reading), but the author has a set of slides that you can read after the book to get the recent changes: https://www.slideshare.net/opersys/presentations
​
Another useful book is https://www.amazon.com/Embedded-Programming-Android-Bringing-Scratch/dp/0134030001 . This one focuses more on getting AOSP running on a new device, and not that much in its internals or customization.
​
Two newer books I have recently found (although I haven't had time to read them) are https://www.amazon.com/Android-System-Programming-customizing-debugging/dp/178712536X (same author as the previous one, content mostly related to building the kernel and getting AOSP running in a new device/emulator) and https://www.amazon.com/Learning-Embedded-Android-N-Programming-ebook/dp/B01841W9AU
They are still pre-treble, but they are probably still useful.
​
Besides those, if you want something more related to internals and not so much on how to "get the source code and build AOSP", you could check https://www.amazon.com/Android-Security-Internals-Depth-Architecture/dp/1593275811 and https://www.amazon.com/Android-Hackers-Handbook-Joshua-Drake/dp/111860864X
Here is a breakdown of what you need to do/know as an Embedded Developer (STM32 based):
1- Understand your tools.
Understand how to use embedded development tools such as compilers, debuggers (hardware and software) and built environements. You can go the GCC-ARM+Make+openOCD/texane_stlink route but this is a time-consuming process and though I do recommend it, it is not necessary. Almost all vendors have a free development IDE available nowadays. For STM32, have a look at their System workbench IDE developed along with AC6. It is eclipse based and includes compiler and integrated openOCD for debugging. The STM32CubeMX code generator is also a very nice tool.
For debuggers, there are plenty of official and unofficial STLink debuggers that can be bought for anywhere between $5-$200. The cheaper ones work great. All ST-Nucleo boards come with built-in debuggers. If you intend to use other ARM chips have a look at the JLink debugger. It's more expensive but worth every penny.
For simply programming the STM32, you can use the STLink debugging hardware, ST-Nucleo drag and drop programmer, or the bootloader. All STM32s come with builtin USB/Serial bootloaders that can be activated via changing voltage levels on the BOOT0 and reset pins. This is a really neat feature that all STM32 developers need to be familiar with.
​
2 - Understand your hardware.
Read the reference manual for whatever chip that you are interested in. Know the chips memory map. You also need to understand how to perform bitwise manipulations in C. Specifically you need to be able to:
- set/clear & toggle one or more bits in a register
- test the state of a particular bit or group of bits in a register
You should leverage the information in the reference manual and knowledge of bitwise manipulation to write your own simple GPIO and Serial driver functions (polling based). Same goes for simple peripherals including SPI, I2C, ADC, DAC, Timers, PWM, and even the onboard DMA.
You also need to be familiar with the CPU's/SOC's Interrupt architecture i.e. how to enable/disable interrupts globally, locally and write your own Interrupt subroutines.
If you can do this then you understand the hardware enough to bend it to your will. You do not need to know the CPU architecture i.e. pipelining, caching e.t.c though it does not hurt and will occasionally come in handy.
​
3 - Understand how to use the hardware vendor's provided API.
Writing your own drivers is great but the hardware vendor's API provides better portability and is `usually` better tested and supported than custom drivers. Also writing custom drivers for more advanced peripherals such as USB, Ethernet, SD card interface e.t.c. can be quite a challenge. It's better to utilize the available vendor API instead for those big boy peripherals . Don't try to jump directly to the Vendor API for all peripherals though. Understand the hardware and at least build and test a couple of simple custom drivers as mentioned in step 2.
​
4- Understand how to use an RTOS.
Nowadays more and more projects rely on a real-time operating system(RTOS). FreeRTOS is a very good and popular choice. Learn how to use it. RTOS knowledge and use is essential for large embedded developer projects.
​
Books:
- Carmine Novello's Mastering STM32
- Muhammamd Ali Mazidi's STM32 Arm Programming for Embedded Systems
- Jim Cooling's Real-time Operating Systems Book 2 - The Practice: Using STM Cube, FreeRTOS and the STM32 Discovery Board
- Warren Gay's Beginning STM32
Good luck
If, after reading the handbook, you find you still want a deeper dive check out The Design and Implementation of the FreeBSD Operating System
It's not the easiest thing to break into, but possible. I think the reason for that is because it's hard to find entry level embedded jobs because of the level of investment before someone can operate. For example, you can hire an entry level web developer, and within 3-4 months they will be ready to go on small tasks. Embedded industry, the upfront learning can take much longer (imo). On top of that, the amount of things that can go wrong, and the amount of knowledge to debug when shit hits the fan, is way higher. But it sounds honestly like you've done some of that investment already, and that's attractive. When I was hired as an embedded engineer, I didn't know what SPI/I2c was, how to read a schematic, etc.
The hard thing is that the simplest thing in embedded world can take a while to learn, and once you learn it you don't think it's good enough, or "oh that's easy'. Those are the building blocks that are needed, and while they're not exactly difficult it takes time to wrap your head around trading bits down a wire during SPI. Reading datasheet, using the awful ides that come in the world, the lingo, all of that is simple stuff but takes time to learn, and it sounds like you've invested enough to know some of the stuff you're talking about. An employor knows you don't have to spend time coming up to speed with. In short, those low level protocols are knowledge worth bragging about.
You say you have a C.S. degree, but that is very much worth something. I work alongside electrical engineers and people with non CS degrees, and I shine when it comes to design patterns and figuring out alternative methods when tackling a problem with constraints. It comes in handy and is not useless, in the end, you're still writing software. I have also found that I have an easier time switching layers and environments than my peers who are non-CS, and want to stay in one area of problem.
I guess this is a random stream of consciousness, but in the end, it's possible. It sounds like you're on the right track and would be able to keep up during an interview. Apply and see what happens, you more than you think. And what you don't know, is okay! Be honest with yourself, you've done what you can.
I really recommend a book for all learner's of embedded systems, Making Embedded Systems. All of that stuff is important, and during my embedded career I look back through it and say "wow, this information was in this book the entire time". Lots of gold.
I started early on with Arduino and moved into lower level embedded with the stm32 discovery line of development boards. Attached link of a good starting board that has tons of example code from ST.
https://www.mouser.com/ProductDetail/STMicroelectronics/STM32F407G-DISC1?qs=mKNKSX85ZJejxc9JOGT45A%3D%3D
If you want a decent intro book into embedded topics, this book does a decent job of introducing the different parts of working on an embedded project:
https://www.amazon.com/Making-Embedded-Systems-Patterns-Software/dp/1449302149
​
Between the Arduino and Pi, the Arduino is more representative of an embedded device. It introduces you to resource constrained system that can be a good starting point for working with digital and analog io's and can let you hook up to communication bus enabled peripherals that use UART, I2C, and SPI. The biggest problem is that it will not introduce you immediately to debugging and standard compilation tools. However, arduino has been a starting point for many developers. Good luck!
I have noticed this in my neck of the woods as well.
From my understanding I think it has a lot to do with people realizing that for many newer embedded applications, a RTOS isn't really necessary, and if you can afford the resources, developing on linux is much easier compared to traditional bare-metal programming/RTOS.
That being said, the only experience I have with this is reading a book. Maybe it could be a good starting point for you too:
Here is the amazon link
The Design and Implementation of the FreeBSD Operating System
Also, the devs hang out on the mailing lists and some on the FreeBSD forum.
The source in the littleosbook builds on itself each chapter. However, it's important to know that the littleosbook, osdev wiki and most online resources aren't necessarily "tutorials" after the bootloader and bare-bones stages. Any later information is going to be more abstract and guidance. If you need in depth assistance with osdev, you'll want to invest in one (or more) of the following:
And a lot of your personal time.
Bootstrap Yourself with Linux-USB Stack: Design, Develop, Debug, and Validate Embedded USB Systems
>ISBN-10: 1435457862 | ISBN-13: 978-1435457867 | Publication Date: March 17, 2011 | Edition: 1
>Learn to design, develop, and validate USB systems with ease, using this valuable resource that provides a detailed bootstrap session on the Linux-USB design and implementation. BOOTSTRAP YOURSELF WITH LINUX-USB STACK offers a tour of the Linux-USB stack, explaining how to develop drivers for USB device and host controllers on Linux. It moves on to explore the interfaces and data structures of a USB module with UML diagrams, concluding each chapter with a sample implementation that applies the information just covered. A comprehensive look at the various tools and methods available on Linux to validate a USB system is also provided. Using a straightforward writing style, this book is a powerful tool for anyone learning to develop a protocol stack with proper architecture and design, ultimately leading to better quality, maintainability, and testability.
Here's a few books I highly recommend:
Making Embedded Systems by Elecia White
An Embedded Software Primer by David Simon
Programming Embedded Systems in C and C++ by Michael Barr - out of print, but still a decent book.
Also, embedded guru Jack Ganssle has a long list of embedded books he's reviewed here: http://www.ganssle.com/bkreviews.htm - lots of good stuff on there
you can check out the table of contents on amazon http://www.amazon.com/Design-Implementation-FreeBSD-Operating-Edition/dp/0321968972/ref=dp_ob_title_bk
or the books website http://ptgmedia.pearsoncmg.com/images/9780321968975/samplepages/9780321968975.pdf
but the answer to all your questions is basically yes, this is the book that fits your criteria.
For the lazy
I noticed you linked to the first edition. Here is the second edition
It's about 40 years too late for any one person to have mastery of all the different parts of a computer.
For computer architecture, Hennessy and Patterson is the classic volume. For the software algorithms that are used everywhere, CLRS is the classic guide. For Operating Systems, The Design and Implementation of FreeBSD is a good book. I'm sure there's something similar for networking.
You could read the PCI spec, and some Intel data sheets, and the RFCs for networking protocols if you want to learn those things. For most parts of computers, I strongly suspect that most material is either too high level (yet another "Introduction to") or too low level (reading an RFC doesn't tell you whether it's used that way in practice or has been superseded).
The only way I've gotten to know things is to play with them. Change the code, make it do something else. Personal research like that is very educational but time consuming, and there's way too much out there to know everything, even for a single small piece of hardware and its associated software.
Not a course, but part one and two of Cooling's books are phenomenal
Real-time Operating Systems Book 2 - The Practice: Using STM Cube, FreeRTOS and the STM32 Discovery Board (The engineering of real-time embedded systems) https://www.amazon.com/dp/1973409933/ref=cm_sw_r_cp_apa_FTUNBbDNDHF12
Disk drives are like post office boxes. They are numbered from one to whatever, and each one holds just a small amount of information. Each of these "boxes" is called a block.
Users like to look at documents organized into folders. Each document has its own name and can have any amount of data.
A filesystem is the software that converts from documents and folders the way users like to see them to the blocks that disk drives hold. For every file, there is some information about who owns it, when they last changed it, which blocks hold the actual data, and so on. (This is an inode.)
For details, I'd recommend The Design and Implementation of the FreeBSD Operating System.
if you don't want a discussion but the real deal, you can have a look at this:
Probably you know about this, might be exactly what you need regarding usage:
http://bhami.com/rosetta.html
edit: forgot the excellent https://www.amazon.com/Mac-OS-Internals-Approach-paperback/dp/0134426541
Great book:
https://www.amazon.com/Making-Embedded-Systems-Patterns-Software/dp/1449302149/ref=sr_1_1?ie=UTF8&qid=1525458632&sr=8-1&keywords=embedded+systems+elecia+white
This book is awesome.
​
https://www.amazon.com/Embedded-Linux-Primer-Practical-Real-World/dp/0137017839
This book is far and away the best resource I have found for Android internals: https://www.amazon.com/Embedded-Android-Porting-Extending-Customizing/dp/1449308295
Unfortunately it is out of print, I read it on safaribooksonline.com but you can probably find copies elsewhere too.
Initially I watched an episode of lunduke hour that featured a freeBSD dev https://www.youtube.com/watch?v=cofKxtIO3Is
I like the documentation available to help me learn. I got my hands on the FreeBSD handbook and can't wait to get into the design and implementation text book, Addison Wesley, 928 pages. https://www.amazon.com/Design-Implementation-FreeBSD-Operating-System/dp/0321968972/ref=pd_lpo_sbs_14_t_0/143-0574353-4482766?_encoding=UTF8&psc=1
I appreciate the focus on servers and research computing that is BSD's strong suit.
http://www.amazon.com/Design-Implementation-FreeBSD-Operating-System/dp/0321968972/ref=sr_1_1?ie=UTF8&qid=1418830375&sr=8-1&keywords=BSD
http://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1418830402&sr=8-1&keywords=kernel
http://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1418830420&sr=8-2&keywords=kernel
http://www.amazon.com/Art-Linux-Kernel-Design-Implementation-ebook/dp/B00L2EBELM/ref=sr_1_3?ie=UTF8&qid=1418830446&sr=8-3&keywords=kernel
http://www.amazon.com/Professional-Kernel-Architecture-Wolfgang-Mauerer/dp/0470343435/ref=sr_1_5?ie=UTF8&qid=1418830461&sr=8-5&keywords=kernel
Here's the newest edition of the cookbook:
https://www.amazon.com/gp/aw/d/1788399218/ref=dp_ob_neva_mobile
https://www.amazon.com/Making-Embedded-Systems-Patterns-Software-dp-1449302149/dp/1449302149/ref=mt_paperback?_encoding=UTF8&me=&qid=
The Design and Implementation of the FreeBSD Operating System is suppose to be a good one.
That is not true. Sync writes go to memory (in a transaction group) and the SLOG at the same time.
The only reference I know of for this is in this book: https://www.amazon.com/dp/0321968972/
Section 10.4, logging. You can see it in the Amazon preview, starting on page 538.
Oh hell no. I have much less time to play and tinker than I did in my 20s/college years. All/most of the current and new understanding does come from my background but mostly my jobs.
I started as a system admin, loved Linux so much I focused on that, got a job as a mid, then a job as a senior Linux SA. My senior SA job was for a small electronic research lab and I once I had their environment solid and automated I had more free time for other work so I took on more typical System Engineer duties and worked on their software build environments. Git/Jenkins/Compilers (GCC, Intel CC, and Intel Fortran) as well as migrating their build code from M4/autotools to CMAKE and Python. Anyways, they also had side projects for porting their code-base to new mobile devices so I learned a lot from that. Simple programs are really as easy as having your toolchain in place and build...but the easiest would be just get say a Raspberry Pi and natively compile.
I might recommend a good book co-authored from Jon Masters, the Chief ARM Architect at Red Hat (great guy IRL BTW, had a few pints few years back at a conference. We both used to be quite fat/obese so we hit it off about that and Linux/ARM)
https://www.amazon.com/Building-Embedded-Linux-Systems-Techniques/dp/0596529686
But back to your original point; I'm in my mid thirties but already see people 10 years younger than me that know the newest tools and shiny new things but I have a more solid understanding of the big picture. My advice is find a niche, focus on it, but also make sure you know/understand everything else. You would be amazed how quickly you can go from not ever touching a new tech or piece of software to a good understanding as long as you have that core fundamentals down.
It just takes years of moving around and touching everything you can get your hands on and loving every bit of it. That is key to this field, you have to love it.
Edit:
You really want to learn Linux and compiling then do the Linux From Scratch.
http://www.linuxfromscratch.org
There aren't any that I'd recommend, unfortunately.
This book is not specifically about embedded C, but about embedded in general:
https://www.amazon.com/Making-Embedded-Systems-Patterns-Software/dp/1449302149
Anything by Jack Ganssle is good as well.
Check out the Porting and Tuning sections.
Also, the book Embedded Android is good (but getting old) and the guy who wrote it, Karim Yaghmour, as some videos on YouTube, if you prefer that.
I'm currently reading 'AVR Microcontroller and Embedded Systems' by Muhammad Ali Mazidi. I'm on chapter 4 and it's pretty good but I did have to go back a read a little bit.
http://www.amazon.com/AVR-Microcontroller-Embedded-Systems-Electronics/dp/0138003319/
This here is a FULL and DIRECT download of the same book that I just happen to find about a month ago, 100% legit, no malware...
http://www.radiosovet.ru/book/mikroelektronik/programmirovanie/2681-the-avr-microcontroller-and-embedded-systems-using-assembly-and-c.html
Also very strange that I came across your question that you just asked 4 hours ago through a search engine.
This is a short tutorial on the very basics. I have my programmer, breadboard, and all of it set up, I'm just waiting on my microcontroller chips in the mail.
http://www.micahcarrick.com/tutorials/avr-microcontroller-tutorial/getting-started.html
Check out the embedded podcast and blog, and the book "Making Embedded Systems"
https://www.embedded.fm/
https://www.amazon.com/Making-Embedded-Systems-Patterns-Software/dp/1449302149
May I ask you the reverse question? I'd be interested what it takes to move from embedded to backend.
Embedded is a wide field. It kind of depends on whether you're developing firmware or the application layer for an embedded target. Principally it's not much different than programming normal C, but for a lot of targets there's no malloc (because it can have disastrous timing behavior) and you'll need to learn about hard real-time scheduling and working with peripherals.
If you work closely with the hardware guys it might be useful to know the basics of handling an oscilloscope.
For the basics I can recommend [this book here].(https://www.amazon.com/Making-Embedded-Systems-Patterns-Software/dp/1449302149)
Not sure what your budget is (buy used books or South Asia editions), but you may find the following useful :-)
Also, unless required, avoid programming in assembly but use C/C++ exclusively. This allows you to carry over much of your acquired knowledge across various MCU families.
and finally;
Unfortunately, there's almost no "OpenBSD" kernel books in the wild. However you can glean from the OpenBSD source, the mailing lists, and https://www.amazon.com/Design-Implementation-FreeBSD-Operating-System/dp/0321968972/ref=sr_1_1?ie=UTF8&qid=1517846809&sr=8-1&keywords=The+Design+and+Implementation+of+the+FreeBSD+Operating+System
Okay, you're definitely at the beginning. I'll clarify a few things and then recommend some resources.
I feel like I've gone off on a few tangents, but just ask for clarification if you want. I'd be happy to point you towards other resources.
I'm an embedded software developer who used to use C and now primarily works with C++.
Learning C is relatively easier when you start off and gives you a better appreciation of memory handling and it's complexities than C++ does in my opinion. The C knowledge will also transfer well to C++.
C++ is definitely a much more powerful language and you can get your tasks done quicker with it. There are a lot of things to learn in C++, but you can get them with time. A lot of embedded processors, particularly the ARM based ones, support C++ as well, so that is not a problem
Like someone else mentioned though, embedded development relies on a good knowledge of programming as well as a good understanding of computer architecture.
Here's a nice book I've read which is useful for new embedded developers - Making Embedded Systems: Design Patterns for Great Software https://www.amazon.com/dp/1449302149/ref=cm_sw_r_cp_apa_i_MuFhDb1WWXK3W
O'Reilly Publishing is a reputable source for programming in general. Here is an embedded systems book.
Edit; stupid formatting
The Design and Implementation of the FreeBSD Operating System by Marshall Kirk McKusick
Though it uses FreeBSD-specific details, its breadth and level of detail is really high, with most of the concepts being applicable to nearly all Unix-likes, and much of it to operating systems in general.
The second edition came out just a few days ago, which I link to.
AVR
http://www.amazon.com/AVR-Microcontroller-Embedded-Systems-Electronics/dp/0138003319
This may interest you: in Embedded Software Development for Safety-Critical Systems the author says
> The question of what is the best programming language to use for the development of a safety-critical embedded device is a perennial topic in both Internet and face-to-face discussion groups. My personal choice would perhaps be D or RUST, particularly if confidence can be generated in the compilers.
Im not sure the applicability (2A BTW), but i picked up a freeBSD textbook and its pretty good on OS content.
https://www.amazon.ca/Design-Implementation-FreeBSD-Operating-System/dp/0321968972/ref=dp_ob_title_bk
I think the content is different, but the theory and concepts are there.
Need a PDF of these(willing to pay $8 each): Venmo or Paypal
https://www.amazon.com/Embedded-Cortex-M-Microcontrollers-Assembly-Language/dp/0982692668/ref=sr_1_1?s=books&ie=UTF8&qid=1537452433&sr=1-1&keywords=Embedded+Systems+with+ARM%C2%AE+Cortex-M%2C+Third+Edition&dpID=51%252BE9C%252BHCoL&preST=_SX218_BO1,204,203,200_QL40_&dpSrc=srch
and
https://www.amazon.com/Introduction-Practice-Statistics-David-Moore/dp/1319013384/ref=sr_1_1?s=books&ie=UTF8&qid=1537452296&sr=1-1&keywords=Introduction+to+the+Practice+of+Statistics+9th+Edition
and
https://www.amazon.com/Engineering-Economic-Analysis-Donald-Newnan/dp/0190296909/ref=sr_1_1?s=books&ie=UTF8&qid=1537452380&sr=1-1&keywords=engineering+economic+analysis+13th+edition&dpID=515OCpACOGL&preST=_SX218_BO1,204,203,200_QL40_&dpSrc=srch
http://www.amazon.com/gp/product/0321968972/
Need a PDF of this book
Embedded Systems with ARM® Cortex-M, Third Edition
Will pay through PayPal
https://www.amazon.com/gp/aw/d/0982692668/ref=dp_ob_neva_mobile
Well, it is copyrighted by Kirk McKusick, who was a core contribute in the early days of FreeBSD, and he has a restriction that it only be used tastefully (so there's some subjectivity to it). I don't know if he still works on it as a core contributor though, but he did recently release v2 of The Design and Implementation of the FreeBSD Operating System, so he's involved in some capacity.
I'm not sure of the legal restrictions on the new FreeBSD logo, Beastie or Tux so you may very well be right they they don't need to be defended.
> For those who prefer video lectures, Skiena generously provides his online. We also really like Tim Roughgarden’s course, available from Stanford’s MOOC platform Lagunita, or on Coursera. Whether you prefer Skiena’s or Roughgarden’s lecture style will be a matter of personal preference.
>
> For practice, our preferred approach is for students to solve problems on Leetcode. These tend to be interesting problems with decent accompanying solutions and discussions. They also help you test progress against questions that are commonly used in technical interviews at the more competitive software companies. We suggest solving around 100 random leetcode problems as part of your studies.
>
> Finally, we strongly recommend How to Solve It as an excellent and unique guide to general problem solving; it’s as applicable to computer science as it is to mathematics.
>
>
>
> [The Algorithm Design Manual](https://teachyourselfcs.com//skiena.jpg) [How to Solve It](https://teachyourselfcs.com//polya.jpg)> I have only one method that I recommend extensively—it’s called think before you write.
>
> — Richard Hamming
>
>
>
> ### Mathematics for Computer Science
>
> In some ways, computer science is an overgrown branch of applied mathematics. While many software engineers try—and to varying degrees succeed—at ignoring this, we encourage you to embrace it with direct study. Doing so successfully will give you an enormous competitive advantage over those who don’t.
>
> The most relevant area of math for CS is broadly called “discrete mathematics”, where “discrete” is the opposite of “continuous” and is loosely a collection of interesting applied math topics outside of calculus. Given the vague definition, it’s not meaningful to try to cover the entire breadth of “discrete mathematics”. A more realistic goal is to build a working understanding of logic, combinatorics and probability, set theory, graph theory, and a little of the number theory informing cryptography. Linear algebra is an additional worthwhile area of study, given its importance in computer graphics and machine learning.
>
> Our suggested starting point for discrete mathematics is the set of lecture notes by László Lovász. Professor Lovász did a good job of making the content approachable and intuitive, so this serves as a better starting point than more formal texts.
>
> For a more advanced treatment, we suggest Mathematics for Computer Science, the book-length lecture notes for the MIT course of the same name. That course’s video lectures are also freely available, and are our recommended video lectures for discrete math.
>
> For linear algebra, we suggest starting with the Essence of linear algebra video series, followed by Gilbert Strang’s book and video lectures.
>
>
>
> > If people do not believe that mathematics is simple, it is only because they do not realize how complicated life is.
>
> — John von Neumann
>
>
>
> ### Operating Systems
>
> Operating System Concepts (the “Dinosaur book”) and Modern Operating Systems are the “classic” books on operating systems. Both have attracted criticism for their writing styles, and for being the 1000-page-long type of textbook that gets bits bolted onto it every few years to encourage purchasing of the “latest edition”.
>
> Operating Systems: Three Easy Pieces is a good alternative that’s freely available online. We particularly like the structure of the book and feel that the exercises are well worth doing.
>
> After OSTEP, we encourage you to explore the design decisions of specific operating systems, through “{OS name} Internals” style books such as Lion's commentary on Unix, The Design and Implementation of the FreeBSD Operating System, and Mac OS X Internals.
>
> A great way to consolidate your understanding of operating systems is to read the code of a small kernel and add features. A great choice is xv6, a port of Unix V6 to ANSI C and x86 maintained for a course at MIT. OSTEP has an appendix of potential xv6 labs full of great ideas for potential projects.
>
>
>
> [Operating Systems: Three Easy Pieces](https://teachyourselfcs.com//ostep.jpeg)
>
>
>
> ### Computer Networking
>
> Given that so much of software engineering is on web servers and clients, one of the most immediately valuable areas of computer science is computer networking. Our self-taught students who methodically study networking find that they finally understand terms, concepts and protocols they’d been surrounded by for years.
>
> Our favorite book on the topic is Computer Networking: A Top-Down Approach. The small projects and exercises in the book are well worth doing, and we particularly like the “Wireshark labs”, which they have generously provided online.
>
> For those who prefer video lectures, we suggest Stanford’s Introduction to Computer Networking course available on their MOOC platform Lagunita.
>
> The study of networking benefits more from projects than it does from small exercises. Some possible projects are: an HTTP server, a UDP-based chat app, a mini TCP stack, a proxy or load balancer, and a distributed hash table.
>
>
>
> > You can’t gaze in the crystal ball and see the future. What the Internet is going to be in the future is what society makes it.
>
> — Bob Kahn
>
> [Computer Networking: A Top-Down Approach](https://teachyourselfcs.com//top-down.jpg)
>
>
>
> ### Databases
>
> It takes more work to self-learn about database systems than it does with most other topics. It’s a relatively new (i.e. post 1970s) field of study with strong commercial incentives for ideas to stay behind closed doors. Additionally, many potentially excellent textbook authors have preferred to join or start companies instead.
>
> Given the circumstances, we encourage self-learners to generally avoid textbooks and start with the Spring 2015 recording of CS 186, Joe Hellerstein’s databases course at Berkeley, and to progress to reading papers after.
>
> One paper particularly worth mentioning for new students is “Architecture of a Database System”, which uniquely provides a high-level view of how relational database management systems (RDBMS) work. This will serve as a useful skeleton for further study.
>
> Readings in Database Systems, better known as the databases “Red Book”, is a collection of papers compiled and edited by Peter Bailis, Joe Hellerstein and Michael Stonebreaker. For those who have progressed beyond the level of the CS 186 content, the Red Book should be your next stop.
>
> If you insist on using an introductory textbook, we suggest Database Management Systems by Ramakrishnan and Gehrke. For more advanced students, Jim Gray’s classic Transaction Processing: Concepts and Techniques is worthwhile, but we don’t encourage using this as a first resource.
>
> (continues in next comment)
https://www.amazon.com/dp/0982692668/ref=cm_sw_r_sms_apa_i_3.QvDb45VCMYC
https://www.amazon.com/dp/0128015071/ref=cm_sw_r_sms_apa_i_sbRvDbK9J2Q73
The former is a fantastic book teaching you a specific microcontroller (but the concepts are not cortex-m4-specific). This is the microcontroller we used in my undergrad. You can get Discovery boards with this microcontroller alongside that book. STMicro makes a couple different boards for decent prices.
I agree. I was recommended this one:
https://www.amazon.com/Embedded-Linux-Development-Project-Cookbook/dp/1788399218/ref=nodl_
When I asked here a couple of months ago and it’s been helpful as well.
I was going to study for it through the remainder of the year. From what I have read on forums the following holds:
I passed the ISSEP exam about a month ago (1023 in the US last count) and have not heard back from the folk at (ISC)2 yet - can't put in on my tag line until then. The ISSAP looked interesting given my background in Software Architecture and Design/Systems Engineering. So I will start studying for it in the next 6 months.
https://www.amazon.com/Embedded-Linux-Primer-Practical-Real-World/dp/0137017839
That one? Isn't that more high level though?
I wouldn't exactly say the programming is easy... there's a lot of new ideas and vocabulary to become familiar with.
I am fairly new in microcontrollers and am still confused about a lot of things. Writing bootloaders/brickloaders, watchdog timers, configuring fuse bits, handling interrupts, prescalers, timers, adjusting pwm frequencies, i2c/spi/uart/1-wire/usb, ethernet, wifi... the list goes on...
Not to mention the techniques for optimization/memory handling/reduction of power consumption...
There's a lot of concepts related to hardware programming that you just won't encounter when say, writing console applications.
With that being said, I haven't found a complete tutorial series on youtube, but Human Hard Drive has a decent intro to AVR programming and I found this book to be a helpful introduction to the topic.
Here's a much more recent book:
https://www.amazon.com/Linux-Device-Drivers-Development-customized/dp/1785280007/
Still about ~$40 but at least it sounds like it's relevant to the 4.x kernel.
As already mentioned Mastering Embedded Linux Programming is a very good book about the topics you're interested in. Did you also have a look at Building Embedded Linux Systems? There is also Embedded Linux Primer, 2nd Edition, by Chris Hallinan, or Linux for Embedded and Real-Time Applications, 3rd Edition, by Doug Abbott, which are very good. Each covers the topics you're interested in; by the end of the day it's quite subjective which writing style you prefer.
I would suggest also picking up this one
http://www.amazon.com/Making-Embedded-Systems-Patterns-Software/dp/1449302149/ref=sr_1_1?ie=UTF8&qid=1417370827&sr=8-1&keywords=making+embedded+systems
As for AVR versus PIC, really doesn't matter. I like to use PICs just because I prefer the way their documentation is handled and they seem to have more specialized silicon for specific projects.
HOWEVER, I would play the devils advocate and say neither. Start looking at development boards made by TI or Renesas. They ship more units and if you can get an embedded job you'll more likely be working with those toolchains.
you mean about the board or what ? i've used udoo neo board.
Actually, for the device drivers, i highly recommend this book: Linux Device Drivers Development: Develop customized drivers for embedded Linux https://www.amazon.com/dp/B073V4LKWN/ref=cm_sw_r_cp_apa_i_RKWZDbQKYWEG1
>> You are confusing sections with segments
> and you're behaving the way C++ usually behave
I am not a C++ anything. I have 25 years of experience with C and 20 years of experience with operating system design and development. The odds are better than even that both the computer you used to post this abusive rant and the computers which reddit use to store and serve it run code that I have written.
(Yes, I've been writing C++ on and off for almost as long as I've been writing C, but I vastly prefer the latter.)
> code section or code segment or text section or test segment are same in this context
Absolutely not. Segments are a feature of some computer architectures, most prominently the Intel 8086 and 80386 (but not their 64-bit descendants), used to organize and access code and data in memory. Sections are a feature of most executable file formats (such as ELF and COFF) used on modern non-embedded platforms. The OS and / or the run-time linker read code and data from sections in the executable file and store them somewhere in memory.
> simple googling gives you the result: https://stackoverflow.com/questions/2589949/string-literals-where-do-they-go
Stack Overflow is not a reliable source of correct* information (see for instance this article or this one about how SO's karma system encourages a race to the bottom). I would suggest reading Tanenbaum or McKusick et al. instead.
This specific answer is correct only in the sense that the literals are included in the same file as the code. Setting aside embedded platforms and their idiosyncrasies, they are stored in different sections of the file and loaded into different memory locations at run-time.
> Where do they go? the same segment where the .text section of the object file gets dumped, which has Read and Exec permissions, but not Write
Your information is 20 to 30 years out of date. No modern OS uses segments the way Intel envisioned when they designed the 8086 or the 80386. The former needed segments to escape pointer size limitations when the address bus outgrew the registers, and the latter retained them for backward compatibility and added memory protection features on a per-segment basis. However, modern OSes for the 80386 and its descendants implement memory protection at the page table level rather than at the segment level and use segment registers purely as conveniences for array operations, which is why they were left out when the 80386 architecture was expanded to 64 bits.
> But go ahead c++ pleb continue **** your *** like your kind always does.
I understand that it can be hard to admit that you are wrong, but that's not a reason to resort to that kind of language.
Care to elaborate on what you mean by functional program framework?
Are you talking about doing functional programming in C? I think there is a book on that. I think it's this one: http://www.amazon.com/Functional-C-International-Computer-Science/dp/0201419505/ - I'm not so sure though.
Are you talking about building framework/programs that are functional (as in robust, secure, ...)? If that is the case, then there is an interesting book named "C Interfaces and Implementations" going through several kinds of modules you might want to implement in C, and going through how you'd elaborate an interface and an implementation for them => http://www.amazon.com/Interfaces-Implementations-Techniques-Creating-Reusable/dp/0201498413/. This book covers the sort of thing that I believe you should be studying after learning the overall language syntax and semantics, how to combine features of C to solve not so trivial algorithmic problems, and so forth. In summary, it talks about modules design (both interfaces and implementations) in C.
There are more books here, like those listed in here http://www.iso-9899.info/wiki/Books. You can also check some more learning resources here http://www.iso-9899.info/wiki/Usenet and here http://www.iso-9899.info/wiki/Web_resources.
Still on my second interpretation of your functional program framework (because idk much about the first one besides that book "Functional C"), there are tons of very complicated systems built in C, like operating systems, server software, and so forth. And for many of them, there were books written. Here are some software for which you can find books on their design and implementation:
There are probably more, but those are the one which came to mind.