(Part 2) Best microprocessor & system design books according to redditors
We found 568 Reddit comments discussing the best microprocessor & system design books. We ranked the 161 resulting products by number of redditors who mentioned them. Here are the products ranked 21-40. You can also go back to the previous section.
![Apple Machine Language for Beginners (Compute] Books)](https://m.media-amazon.com/images/I/51T3vrosoqL.jpg)
Whenever I get an email about a new programming Humble Bundle, I hop over to Reddit to see if anyone else thinks it's worth buying. In this case, Reddit has failed me, because no one has shared their opinions. All is not lost, however, for I can share mine!
These are probably the most commonly recommended DevOps books:
The Site Reliability Workbook is the only one of these that's included in this bundle. So the first question I ask myself regarding this bundle is, "Do I want to spend the time and money on this bundle's books, or should I spend that on one of the highly recommended books instead?" (Personally, I'm going with the latter.)
Otherwise, most of the books here are technology-specific, so the second question is, "Do I want to learn any of these specific technologies now, and are e-books a good way of doing it?" (Personally, my answer is no.)
Depending on how you answer the first two questions, the last question is, "Are the non-technology-specific books worth getting?" To answer that, here are Amazon links to the non-technology-specific books, for reviews and sales rankings:
Basically any SRE advice for a normal service but replace/compliment HAproxy / nginx / ingress controller / ELB with the Tor daemon / OnionBalance.
I run Ablative Hosting and we have a few people who value uptime over anonymity etc and so we follow the usual processes for keeping stuff online.
Have multiples of everything (especially stuff that doesn't keep state), ensure you have monitoring of everything from connections, memory pressure, open files, free RAM etc etc.
Just think of the Tor daemon onion service as just a TCP reverse proxy, with load-balancing capability and then follow any other advice when it comes to building reliable infrastructure;
Once you've got to grips with running a reliable service then you can start layering your Onion reverse proxy / load balancing on top.
All of this aside, check /u/alecmuffett's "Onions that don't suck" repo for examples that are both well setup and stable.
TL;DR; Tor is just a TCP reverse proxy with load balancer capabilities go learn some DevOps dodads
Edit: As per Alec's comment - clarify that Tor is technically a reverse proxy with load-balancing capabilities rather than a straight up TCP load balancer.
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
Intro
Command Line
You mentioned MIS, which is fine, but from a Computer Science perspective, I can't recommend this book enough:
Computer Architecture
Raspbian has basic programs written in Scratch and Java if you go to /home/user/Documents
You'll have to search under BlueJ and the other IDEs they use. Replace user with the user name.
Have fun :)
I'd check Amazon for older books you can get on the cheap. Schaum's outlines as mentioned are also good.
Books
Forrest Mim's Basic Electronics and Basic Semiconductor Electronics
(Little More Advanced) Art of Electronics (Student guide is probably better for introductory coverage)
http://www.pearsonhighered.com/nilsson/
http://openbookproject.net/electricCircuits/
http://www.oup.com/us/companion.websites/umbrella/sedra/
TI's OPAMPs for Everyone
Analog Devices (ADI's) OPAMP Applications
http://www.amazon.com/Digital-Design-Computer-Architecture-Harris/dp/0123704979
http://www.ddpp.com/
http://www.amazon.com/Digital-Design-4th-Morris-Mano/dp /0131989243
http://www.amazon.com/gp/product/B006FG1HNM/ref=pd_lpo_k2_dp_sr_2?pf_rd_p=486539851&pf_rd_s=lpo-top-stripe-1&pf_rd_t=201&pf_rd_i=0123704901&pf_rd_m=ATVPDKIKX0DER&pf_rd_r=0E8VJTKJAF2SY73PY6V4
Lathi
Oppenhiemer/Proakis or Schaum's Outline
Signal and Systems Made Ridiculously Simple
http://www.pearsonhighered.com/dorf/
I don't have a good suggestion.
Hecht
Balanis
I have several different books in this area, but wouldn't suggest any of them.
TI Unitrode Notes
------------
Resources
Spice
http://www.uta.edu/ee/hw/pspice/
http://williamson-labs.com/
http://dspcan.homestead.com/files/idxpages.htm
http://www.falstad.com/mathphysics.html
Mechanical Universe
http://www.learner.org/resources/series42.html
http://hyperphysics.phy-astr.gsu.edu/hbase/hph.html
------------
Software
http://www.linear.com/designtools/software/
http://www.ieca-inc.com/images/Spice-Simulation_Using_LTspice_Part_1.pdf
http://www.ieca-inc.com/images/Spice-Simulation_Using_LTspice_Part_2.pdf
DSP/Controls
Altera Quartus II
Xilinx ISE
"Digital Design and Computer Architecture" by Harris & Harris
On my related thread, people suggested that I start to program a PIC or a C64.
Here's a list of all the amazing resources that they pointed me to (includes apple II books, that they used)
http://www.whatswhereintheapple.com/
Apple Machine lang for beginners
Gnu programming ground up
http://www.z80.info/zaks.html
List of C64 books
Archived 80s books that are free and online
I don't know of a book for RISC-V creation in Verilog but there is a book on making a Z80 like processor in Verilog. https://www.amazon.com/Microprocessor-Design-Using-Verilog-HDL/dp/0963013351
OK. ModernRonin did a great job. Read his first. Also I'd like to put out the theory that you didn't receive many replies on /r/programming because that is typically a forum for high-level programming, not down-in-the-metal like this.
I've done this plenty of times, and let me tell you from experience, it can be done on the cheap, and pretty easy. Where ModernRonin provided specific answers, I'll try to provide examples of how it might work.
Something like this:
Temp Sensor --> Sensor control board --> PC.
The link between temp sensor and the board is probably I2C (eye-squared-see) or serial port. If it's serial port, you can technically skip the control board directly to the PC. If you're PC doesn't have a serial port (a 9-pin port that looks like a monitor plugin), then you'll have to buy this, which provides a serial port over a USB connection. If you manage that, then you can move on to adding other sensors to the control board. Typically, these extra sensors will all communicate with the control board, which then relays the data all at once to the PC.
Dont' worry about accessing ports, concentrate on the connections (I2C or USB? Serial or Xbee?), then learn how to access what you have.
Start with the control board, I'd recommend something pre-built like an adruino. Then build your own after a month or so. It's so easy you'll never believe it.
"Choosing" ports won't be an issue, each has a purpose, and typically you won't have a lot of flexibility.
Accessing ports is easy. Start with a terminal program. Realterm is the shit. Be friends with it. It'll dump anything coming in over a serial port, which makes debugging really easy.
Most programs will handle accessing the port for you. However, if you want to build your own program (and you will, probably), you'll have to learn how to do this with code. Luckily, libraries will exist to help you, and you won't be inventing anything so much as tweaking pre-existing examples.
Now the hard part is getting the control board set up. This is where people get frustrated and give up. That's why I strongly recommend paying money for this part. The control board will probably be something like an ardruino. I prefer using Microchip's sample program, which gives you access to cheap chips (but you have to know something about laying out a board).
Once you get this down, you can start building your own sensors if you want. Most control boards will have ADC and DAC which will help you with that. However, you probably will NEVER have to build a sensor.
OK. now a list of literature to get you started.
Programming Interactivity
making things talk -- the BEST book for beginners. I loved this book. If I still had my copy I'd mail it to you right now.
Practical Ardruino
And web sites:
Sparkfun -- hobbyist electrical engineering with tutorials
Microchip -- sign up for their free samples when you want to build your own boards
http://www.arduino.cc -- Excellent Beginner Boards
http://beagleboard.org -- Higher level control board, suitable for larger (but still small) embedded projects
Digikey -- catch-all supplier of all things electrical
Oh finally, do send me an msg if you have specific questions.
OP might want to check out Making Things Talk if they don't have much electronics background.
This seems like it would be trivial to do with an Arduino, an audio shield, and a rotary encoder.
Interaction Design
Interior Design
Landscape Architecture
Lighting Design
Product Design
Product Design
Sound Design
Urban Design
* Cities for People by Jan Gehl
Web Design
https://www.amazon.com/Raspberry-Server-Essentials-Piotr-Kula/dp/1783284692
---written by a guy that's an expert in Microsoft
https://www.amazon.com/Learning-Computer-Architecture-Raspberry-Pi/dp/1119183936/ref=pd_sim_14_3?_encoding=UTF8&pd_rd_i=1119183936&pd_rd_r=13E3HAAESNEQPWG1RJAD&pd_rd_w=xMQiO&pd_rd_wg=v978E&psc=1&refRID=13E3HAAESNEQPWG1RJAD
--Yeah there are a lot of Rasp pi books
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.
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
Likewise, but on an Apple ][+. These were invaluable:
Apple Machine Language for Beginners
Apple Machine Language
But mostly this was absolutely required!
What’s Where in the Apple
I'm an ECE that got into Raspberry Pi about a month ago. I work in microelectronics (chip design), and wanted to use it to get back into larger scale electronics hacking and to do some more hardware oriented programming and projects.
As such, I had to basically reform my electronics gadget supply at the same time since I ditched my college collection a while back when moving to a new house.
Here's some of the key things I bought to go with my Pi that I felt I needed. I'm assuming you're like me and want to work on electronics hardware (lights, switches, etc).
Beyond those basic starter components, the rest is up to your imagination and what you want to do next. In my case, I plan to drive higher current components, so I'll be using optocouples and relays eventually. And I plan to make my own PCBs to snap onto the Raspberry, so I have PCBs, headers, and soldering stuff.
If you're new to the Raspberry, there's online resources out there. I also got this book off Amazon as a starter as well, which I've been coupling with online resources.
On the Arduino side, that's my next purchase since I may find it easier to have the software and server side of one of my projects on a Pi, and the hardware interface on an Arduino. I'm just going to get an R3 board to start since I have the rest of the stuff they usually include in a starter pack listed above.
This blog did a nice writeup comparing some Arduino R3 starter kits:
https://www.pretzellogix.net/2014/10/09/three-arduino-starter-kits-compared-and-reviewed/
LDIR - Load Increase and Repeat - the best opcode for all kind of scroll/game loops!
I used to own Rodnay Zaks' book, and program crappy games on my ZX spectrum using the 'champ' assembler-editor!
Good times!
Nand to Tetris (coursera)
the first half of the book is free. You read a chapter then you write programs that simulate hardware modules (like memory, ALU, registers, etc). It's pretty insightful for giving you a more rich understanding of how computers work. You could benefit from just the first half the book. The second half focuses more on building assemblers, compilers, and then a java-like programming language. From there, it has you build a small operating system that can run programs like Tetris.
Code: The Hidden Language of Hardware and Software
This book is incredibly well written. It's intended for a casual audience and will guide the reader to understanding how a microcontroller works, from the ground up. It's not a text book, which makes it even more more impressive.
Computer Networking Top Down Approach
one of the best written textbook I've read. Very clear and concise language. This will give you a pretty good understanding of modern-day networking. I appreciated that book is filled to the brim of references to other books and academic papers for a more detailed look at subtopics.
Operating System Design
A great OS book. It actually shows you the C code used to design and code the Xinu operating system. It's written by a Purdue professor. It offers both a top-down look, but backs everything up with C code, which really solidifies understanding. The Xinu source code can be run on emulators or real hardware for you to tweak (and the book encourages that!)
Digital Design Computer Architecture
another good "build a computer from the ground up" book. The strength of this book is that it gives you more background into how real-life circuits are built (it uses VHDL and Verilog), and provides a nice chapter on transistor design overview. A lot less casual than the Code book, but easily digestible for someone who appreciates this stuff. It culminates into designing and describing a microarchitecture to implement a MIPS microcontroller. The diagrams used in this book are really nice.
Here's the newest edition of the cookbook:
https://www.amazon.com/gp/aw/d/1788399218/ref=dp_ob_neva_mobile
Inside the Machine - Jon Stokes
My personal favorite: programming the Z80
It is about a real 8-bit processor, similar to the ones used in the first PCs, but written and illustrated in such way that a total novice (like I was at the time) can gain a real in-depth understanding.
Actually, I worded it so there isn't an assumption on the languages being discussed, just using Language A and Language B as examples to show the flaw in the methodology used. It may or may not be reality, I don't know, but the article drawing the conclusions don't show that the data they used for the conclusion is valid either. It could be just the opposite, and verilog requires more googling, in that case, the data would be just as flawed.
You are right, they may require similar amounts of googling, Verilog may require much, much more, or it may be VHDL that requires more. However, to make a conclusion from the data (the one in the article is that the google search results represented the number of users, and could be counted on to make a fairly significant decision), you need to show that the data represents what is claimed.
With respect to the decision on what language to learn first, either will work, I learned VHDL before Verilog. The person should use real data based on their needs to make the decision. Look at the industries, schools, etc that you are aiming to work with/in. If you are learning FPGA's as a hobby, what sources are you using to learn, are they VHDL or Verilog oriented. I would also recommend a good book that gives examples in both languages like this, it is an older book, so I would look for a newer one, but it gives examples in both languages side by side. This gives a person exposure to the language they are not using while learning one, making it much easier to learn the second later. Like most programing problems, the language really doesn't matter if you get good fundementals, switching languages becomes a minor issue.
TL;DR: Learn the language that makes sense for your situation first, but don't trust the data from the article to make this decision.
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.
GPIO. There are plenty of user guides floating around, including this one co-written by the creator.
Have you ever heard of [opensecurity training] (http://opensecuritytraining.info)? they have a pretty good introductory Intel x86 course.
The most common resource used is the Intel manual.
If you are looking for some good books I'd recommend the csapp.cs.cmu.edu or the programming from ground up (the last one is best for your needs I think)
The dragon book is a bit dated. I would recommend Engineering a Compiler (Cooper). Though I have heard good things about Modern Compiler Design (Grune).
Stanford's open course on compilers is available on youtube but I can't offer a critique. https://www.youtube.com/watch?v=sm0QQO-WZlM&list=PLFB9EC7B8FE963EB8
Pong P. Chu's "Verilog/VHDL by Example" :
http://www.amazon.com/FPGA-Prototyping-Verilog-Examples-Spartan-3/dp/0470185325/ref=sr_1_2?ie=UTF8&qid=1412004641&sr=8-2&keywords=verilog+by+example
Really good, easy read:
http://www.amazon.com/Bebop-Boolean-Boogie-Third-Unconventional/dp/1856175073/ref=sr_1_3?ie=UTF8&qid=1412004683&sr=8-3&keywords=maxfield+clive
This is an older book, but is pretty cool because it has verilog on one page and VHDL on the other, in addition to showing you how some tools might synthesize it. Meaning you get a schematic of how it was implemented. Very good to learn what hardware gets instantiated by your HDL :
http://www.amazon.com/Hdl-Chip-Design-Synthesizing-Simulating/dp/0965193438/ref=cm_cr_pr_product_top
I found this one very helpful
https://www.amazon.co.uk/Definitive-Guide-Cortex%C2%AE-M0-Cortex-M0-Processors/dp/0128032774
Programming From the Ground Up for low level programming, and how computers actually work.
Also free in PDF from http://savannah.nongnu.org/projects/pgubook/
Check out the pic16f84a. It can be programmed in C, but it's mostly designed to be programmed in assembly. It's really bare bones, but you'll learn alot that can be applied to more complex chips. https://www.amazon.com/Easy-PicN-Beginners-Microcontrollers-Square/dp/0965416208 http://www.canakit.com/usb-pic-programmer.html
This book is a good resource for learning Assembly Language. The author released the book under GNU Free Documentation License and it's also available in PDF format.
I purchased http://www.amazon.com/Guide-Assembly-Language-Concise-Introduction/dp/0857292706/ref=sr_1_10?s=books&ie=UTF8&qid=1331406839&sr=1-10
Check out the dedinitive guide to arm cortex m* by joseph yui. Ive only read the m3/m4 one but it gives a great overviewhttp://www.amazon.com/gp/aw/d/0128032774/ref=mp_s_a_1_2?qid=1453564034&sr=8-2&pi=SY200_QL40&keywords=the+definitive+guide+to+arm&dpPl=1&dpID=51gPqtgAklL&ref=plSrch
Also, a course on edx just started about programming the m4 on a tiva c dev board. (tm4c123gh6pm is the mcu)
edit: link to edx course
https://www.edx.org/course/embedded-systems-shape-world-utaustinx-ut-6-03x
The Raspberry Pi User Guide is pretty good. Not too technical, but provides good info. 11 might be at the low end, but the book should be useful.
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
Here's a book that explains how to create a softcore microprocessor in an FPGA:
https://www.amazon.com/Microprocessor-Design-Using-Verilog-HDL/dp/0963013351/ref=sr_1_6?s=books&ie=UTF8&qid=1504116926&sr=1-6
Inside the machine
Probably my favorite book of all time.
Modern Compiler Design.
The Computer Systems: A Programmer's perspective is a very good book (the only book of which i have all 3 editions!). You can easily get the cheap South Asian editions and save money.
I have found the following two books to be very good;
Guide to Assembly Language: A concise introduction might be what you are looking for (but 32-bit only). It really is concise but very clear.
Searching the web will turn-up digital versions for all of them.
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
I really like the user guide book:
Raspberry Pi User Guide https://www.amazon.co.uk/dp/1119264367/ref=cm_sw_r_cp_tai_x1CDzbAXAC2TN
It offers some basic info to get you up and running and helps a lot with your first steps. Making and breaking the pi is part of the fun with it! I'd recommend having a backup system (I use pibaker on my mac to create backups whenever my tinkering leads to a success, so if/when I break it again I can rollback to my last working version!)
plenty of resources online, not only are they comprehensive, they're also free. But, if you really want to get a book to hold or something, there's a whole series of books about these processors
https://www.amazon.com/Definitive-Guide-Cortex-Cortex-M0-Processors/dp/0128032774/ref=sr_1_2?keywords=cortex-m0&qid=1562115097&s=gateway&sr=8-2
I run tutorials and labs for a "Foundations of Digital Design" unit. We use:
http://www.amazon.com/Digital-Design-Computer-Architecture-Harris/dp/0123704979
From my experience this is a good book, an improvement on what we used to use (Mano & Kime).
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.
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.
EZ Pic'n is an excellent beginners guide to the PIC micro-controller family. I start all of my interns out with it.
http://www.amazon.in/Programming-Ground-Up-Jonathan-Bartlett/dp/0975283847/ref=sr_1_1?ie=UTF8&qid=1468501621&sr=8-1&keywords=Programming+from+the+ground+up
This book is what I have.
Book language is "Linux Assembly X86"
Oh, so higher level is easier? I will research this, and Python Ruby thanks.