If you want more depth, you probably want to pick up a compiler textbook. I liked "Modern Compiler Implementation" (I've used both the C and ML versions) in my undergrad.
What I really mean to say is that your parser doesn't have a lot of effect on the rest of your compiler design. In the end, it's a function that takes input text to an AST. You can go back and replace a YACC generated one later, if you want to know more.
Of course if you choose a simple to parse input language (like lisp) then you can write a simple handwritten parser off the bat.
https://en.wikipedia.org/wiki/Shift-reduce_parsing
https://en.wikipedia.org/wiki/LALR_parser
If you want lots of detail, there is always this:
http://www.amazon.com/Compilers-Principles-Techniques-Tools-...
http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf
Of course, the best is to do both. :)
My series is here: http://www.hokstad.com/compiler/
(I just finished part 34 last night, and the next part goes up on my site in a week or so; I'll shorten my buffer quite a bit over the next two months, I think - I currently have a lead time of about 5 months... )
It starts out fairly generic in terms of code generation, but I then got the stupid or brilliant (you choose) idea of writing a Ruby compiler, which on one hand is very interesting, on the other hand is exceedingly frustrating, and which I think lost me some focus - I really should extract the simple/non-Ruby specific sections into a separate text and clean it up.
In terms of other peoples series, look up Crenshaws "Let's write a compiler" and Niklaus Wirths "Compiler Construction". Bother are available for free online. Frankly, if you google 'How to write a compiler' the results are actually very useful (both books show up on the first page for me).
Though, without reading Modern Compiler Implementation or something similar the use of shift-reduce tables in generated code might not make sense. Also, my computer science curriculum included a course where we wrote a top-down LL(1) parser which is organized very differently with a function call for parsing each rule which calls other functions for parsing sub-rules etc.
I've hand-written a few mangled char-by-char state machines as well, which served as lexers for various DSLs.
https://www.coursera.org/course/automata https://www.coursera.org/course/compilers
I would not call that building a compiler.
Are there any modern tutorials/references of hand-generating the grammar, hand-coding the parser, and hand-coding whatever comes next (because I have no idea, thanks to these new-age tutorials) - without a toolchain, so that the entire process can be seen from start to finish?