Test-Driven Development by Example: by Kent Beck.

also,

Clean Code: by Robert Martin

Have you considered contributing to an open source project that you respect?

Picking a side project is a great way to learn and grow.

If you learn from books, I would recommend Test Driven Development by Kent Beck, Clean Code by Robert Martin, The Philosophy of Software Development

Test Driven Development by Kent Beck is a good book to get you started.

Kent Beck's book: Test-Driven Development

Don't just read it: Work your way through it. You need to follow the recipe to develop the discipline/knack.

Fairly quick and reasonably easy.

I really enjoyed Test Driven Development. I like the simplicity of the rules and the design benefits you get from writing tests first.

Check the book Test Driven Development by Example (Kent Beck)
the second part of the book walks you on to How to build your own testing framework.

Good read

I would focus on communication skills. Knowing what the end user wants is really important.

For technical skills, I recommend reading Clean Code, Test Driven Development, and The Philosophy of Software Design.

A lot of the points in this article are also in other works on the topic such as Kent Beck's Test-Driven Development by Example, and Clean Code by Robert Martin.

What language are you using? If it's Java I found 'Test Driven Development' by Kent Beck a great book if you want to 'get' unit testing and TDD.

There's a gap before when the point of TDD 'clicks' and you see the 'why'; before that it can seem a huge bore. After that it can seem a bore too in some situations but you can see the benefits of it.

I had a similar reaction. It's a nice April fool's joke, but I hoped for an actual counter-balance to "move fast and break things." The book that taught me the value of moving slow in programming was Test Driven Development by Kent Beck, who ironically spent several years at Facebook.

I have also read Test Driven Development By Example. It really opened my eye's to how TDD is suppose to work. Its quite well written. Most of what I have seen on the web does not explain it to any sufficient level.

As Uncle Bob describes in his book, you never even make abstractions until you have proven duplication. You make your abstractions based off of evidence, not hypothetically planned out.

Kent Beck in his book doesn't recommend top-down, or bottom-up, but rather from known-to-unknown. Start with what you know, and work toward what you don't know.

Edit: The books I refer to are Test Driven Development: By Example - Kent Beck, and Clean Code - Robert Martin

Weird suggestion that might help:

My second reading of Test Driven Development, I literally did the entire book along with the author, front to back.

That's when it clicked. The actual manual mechanical kinesthetic activity somehow made it work for me.

Yes, and:

I didn't really grok Test Driven Development until I worked thru the book, line-by-line, experiencing the workflow.

Knowledge vs experience.

Obviously your test case is insufficient.

In Kent Beck's "Test Driven Development by Example", he starts just like this, with an insufficient failing test. Then he writes a minimal function that passes it. Then he adds another test, then improves the function until it passes both. By the time he's done, he's got tests for all the edge cases he could think of.

I think it's a great way to make sure you cover all the edge cases, for a sufficiently complicated function. I don't have the patience to write all my code that way, though.

I would focus on certain fundamentals first. I would also suggest picking a single programming language to learn and learn it well.

Python is one that many people choose as it has many courses and books on learning.

Pick a text editor or IDE and practice with it, the tools you choose can help you a lot.

MIT has a great course 6.00 Introduction to Computer Science.
Udemy has a great Python 3 course Complete Python Bootcamp: Go from zero to hero in Python 3

I would learn a little about Clean Code, I started porting a PHP version to Python https://github.com/tvmaly/clean-code-python it is a work in progress. The book by the Robert Martin is a great way to go if you like books.

I would learn how to test your code, Kent Beck's Test Driven Development book is good and also covers some patterns.

Learn about Object Oriented design, Data Structures, and Algorithms

Learn about version control, git is a good choice

Learn about the command line, it is always a good skill to have

TDD isn't a tool or a library, and thus isn't specific to a language or a framework - it's a philosophy.

Get, read and understand Kent Beck: "Test driven development by example". The rest will follow naturally.

I think we'll end up with some planned and edited screencasts, and some "live coding" streams that are great (with 95% of the live streams being dull.) So there would probably need to be some kind of reputation system or way to look for coders who happen to be interesting in this format.

There are some really good screencasts out there -- I watched some of Kent Beck's Test Driven Development videos and learned way more than I did from the book. (http://pragprog.com/screencasts/v-kbtdd/test-driven-developm...)

Getting Things Done (2001) by David Allen - great method to organize all your tasks and stay on top of things

Clean Coder by Bob Martin - good ideas on being a professional programmer

A Philosophy of Software Design by John Ousterhout - big picture ideas on design

Test Driven Development by Kent Beck - good basis for thinking about design and testing

Legacy Code by Michael Feathers - understanding the issues of legacy code helps us to design better software

Well luckily there is a book for that ;-)

1996. Smalltalk Best Practice Patterns. Prentice Hall. (ISBN 978-0134769042)

1996. Kent Beck's Guide to Better Smalltalk : A Sorted Collection. Cambridge University Press. (ISBN 978-0521644372)

1999. Extreme Programming Explained: Embrace Change. Addison-Wesley. Winner of the Jolt Productivity Award. (ISBN 978-0321278654)

2000. Planning Extreme Programming. With Martin Fowler. Addison-Wesley. (ISBN 978-0201710915)

2002. Test-Driven Development: By Example. Addison-Wesley. Winner of the Jolt Productivity Award. (ISBN 978-0321146533)

2003. Contributing to Eclipse: Principles, Patterns, and Plugins. With Erich Gamma. Addison-Wesley. (ISBN 978-0321205759)

2004. JUnit Pocket Guide. O'Reilly. (ISBN 978-0596007430)

2004. Extreme Programming Explained: Embrace Change, 2nd Edition. With Cynthia Andres. Addison-Wesley. Completely rewritten. (ISBN 978-0201616415)

2008. Implementation Patterns. Addison-Wesley. (ISBN 978-0321413093)

>> Selected papers

1987. "Using Pattern Languages for Object-Oriented Programs". With Ward Cunningham. OOPSLA'87.

1989. "A Laboratory For Teaching Object-Oriented Thinking". With Ward Cunningham. OOPSLA'89.

1989. "Simple Smalltalk Testing: With Patterns". SUnit framework, origin of xUnit frameworks.

There are a lot of them. A lot!

But it depends if you are interested in pure methodology, or you want to see some example of applying it in software/Web development with PHP/Java/RoR/...

From my experience, I found helpful next books:

"Test Driven Development: By Example" by Kent Beck

"Agile Software Development, Principles, Patterns, and Practices" by Robert C. Martin

"Agile and Iterative Development: A Manager's Guide" by Craig Larman

"Agile Project Management with Scrum" by Ken Schwaber

"Agile Software Development Ecosystems" by Jim Highsmith

Those are pretty "technology independent". Helpful to understand the idea. And the authors are respected and well known in the community of agile developers.

If you work with RoR (which is popular choice nowadays) you may find "Agile Web Development with Rails" by Dave Thomas and David Hansson interesting, but it does not cover "agile methodology" itself too wide. But it does give a good overview of practical usage. Anyhow, personally I still prefer to learn theory before practice, but many people see it working for them ;-)

I want to second this idea - Kent Beck is the best place to start. If you find XP too preachy, take a look at his Test-Driven Development: By Example.

It's just the idea behind Test Driven Development, that tests drive development. It won't be very effective as a handover, though could be used as acceptance criterias if that is needed.

The adherents really want tests to be the specification, as a way to be measurable / testable. Specs may be converted to tests.

But most of it is theory. It all depends, as usual, on the dev(s) and circumstances.

One of the coolest cases of this I've seen recently is the second half of Kent Beck's "Test Driven Development: By Example". He uses builds a TDD framework with TDD, using the TDD framework he's building.

For software development - I favor books that are about good practices generally rather than books about particular languages which work well as references.

I usually recommend:

* Code Complete (Steve McConnell)

* The Pragmatic Programmer (Andrew Hunt and Dave Thomas)

* Clean Code and The Clean Coder (Robert Martin)

* The Mythical Man-Month (Fred Brooks)

* Test-Driven Development By Example (Kent Beck)

I also recommend blogs for more bite-sized knowledge. Jeff Atwood's blog at https://blog.codinghorror.com and Joel Spolsky's at https://www.joelonsoftware.com in particular have been helpful to me.

I was recently given this list of books by some very skilled engineers who I trust

1. [The Pragmatic Programmer](https://pragprog.com)
2. Martin Fowler's [Refactoring Book](https://martinfowler.com/books/refactoring.html)
3. Kent Beck's [Test Driven Development: By Example](https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/...)
4. [Thinking in Systems: A Primer](https://www.amazon.com/Thinking-Systems-Donella-H-Meadows/dp...)
5. [Zen Mind, Beginner's Mind: Informal Talks on Zen Meditation and Practice](https://www.amazon.com/Zen-Mind-Beginners-Informal-Meditatio...)
6. [Pragmatic Thinking and Learning: Refactor Your Wetware](https://www.amazon.com/Pragmatic-Thinking-Learning-Refactor....)

If you can't afford 5 min to take a breather, that's when you need it the most.

To quote Kent Beck in the book Test Driven Development, "You're getting tired, so you're less capable of realizing that you're tired, so you keep going and get more tired." It's a feedback loop that makes you even more unproductive.

You don't have to block everything off. One of the best tricks I find is just focusing on what you do. Driving can be very relaxing once you turn off the radio and just focus on the drive. And you don't have to reach peace, just the process will calm you down considerably.

Also as a Muslim, I can also just tell people that I have to pray 5 times a day. Even if you're not Muslim, it's probably a good idea to take quick breaks at fixed hours of the day. Kent Beck recommends drinking a lot of water so that biology will force you to take breaks.

I have hired some PhDs in your situation and worked with others, I personally just went to work after I got my BSEE.

My observation is that you're halfway there when you realize that you need to improve, of the folks I saw who did poorly it was because they didn't realize that you could be both the smartest person in the room and the least capable at the same time.

Right now, on your first job experience, even a kid who never went to college is better at programming than you are because they've been experiencing all the pitfalls that can happen and have built up a knowledge from that which is perhaps more intuitive than formal but serves them well. What you have over that person is that you've trained yourself to consume, classify, organize, and distill massive amounts of information in a short amount of time.

Use that training to consume everything you can on the art of writing programs. Read "Test Driven Development" read "Code Complete", read "Design Patterns", read "The Design of the UNIX Operating System", read "TCP/IP Illustrated Volume 1", and a book or two on databases. With your training you should be able to skim through those to identify the various "tricky bits" and get a feel for what is and what is not important in this new field of yours.

Soak in as much as you can and ask a lot of questions. Pretty soon no one will know you haven't been doing this your whole life.

TDD and XP are not the same thing, either. I don't have my copy of "Test-Driven Development by Example" handy, so I'll just have to point you to http://en.wikipedia.org/wiki/Test-driven_development , which doesn't use unit tests in its definition.

Now, it's not that there's no connection at all: unit tests are _incredibly_ helpful when doing TDD, because you want your tests to run quickly. But it's "Test-first," not "Unit-test first." When you're doing TDD, you don't write acceptance tests second, you write both your acceptance and unit tests first.

- don't only worry about code or getting features shipped, but about the process, how to deliver quality.

- behind any given reason, there is a complex network of real reasons. You don't need to second-guess any decision/order/suggestion, but it helps understanding.

- most user stories / user requests are raw diamonds waiting to be polished. ("What do they really want me to solve")

Essential reading list:

- Clean Coder and Clean Code https://www.amazon.com/Clean-Code-Handbook-Software-Craftsma... https://www.amazon.com/Clean-Coder-Conduct-Professional-Prog...

- Test Driven Development by Kent Beck https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/...

Thanks everyone, the comments are much appreciated. Here's a list of books and other media resources recommended so far in the thread:

Robert C. Martin, Clean code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsma...

Vaughn Vernon, various: https://vaughnvernon.co/?page_id=168

Steve McConnell, Code Complete: https://www.amazon.com/Code-Complete-Practical-Handbook-Cons... 2

Clean coder: https://cleancoders.com/ videos

Hunt and Thomas, The Pragmatic Programmer: https://www.amazon.com/Pragmatic-Programmer-Journeyman-Maste...

Hitchhiker's Guide to Python: https://docs.python-guide.org/

Dustin Boswell The Art of Readable Code: https://www.amazon.com/Art-Readable-Code-Practical-Technique...

John Ousterhout, A Philosophy of Software Design: https://www.amazon.com/Philosophy-Software-Design-John-Ouste... This one looks particularly interesting, thanks AlexCoventry!

Kent Beck, Test Driven Development: https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/...

Dan Bader, Python Tricks: The Book: https://dbader.org/

Ian Sommerville, Software Engineering: https://www.amazon.com/Software-Engineering-10th-Ian-Sommerv...

Svilen Dobrev, various: http://www.svilendobrev.com/rabota/

I haven't gotten a chance to learn UVM yet; is it as awful as VMM? VMM is (arguably) better than nothing, but there's a lot about it that's really broken [1], which can be very frustrating if you're trying to build large-scale exercisers.

If you're interested in the subject, I also recommend reading the book "SystemVerilog for Verification" [2]; it is "the book" on the subject, and although it teaches VMM, it's an excellent reference on the concept of verification to begin with. (It suffers some from the same problem that Kent Beck's Test Driven Development book has -- it verifies excessively simple things -- but IMO, the techniques that it teaches scale much better than Beck's techniques inasmuch as they're actually possible to use in real world applications.)

[1] For instance, for some laughs, take a look at the API reference for the channel datastructure, vmm_channel: http://www.vmmcentral.org/uvm_vmm_ik/files2/vmm_channel-sv.h... -- there is just so much bizarrely wrong that I can't even list it all. "Sneak" is a good place to start, though...

[2]
http://www.amazon.com/SystemVerilog-Verification-Learning-Te...

It has taken me considerably longer than a year. But I might not be smart. And I've tried to do it on my own, rather than taking a job (see prior sentence).

Caveat: I'm not a developer, so my comments about learning how to program should be taken with considerable skepticism. But I have some opinions based my effort to learn.

For me, programming syntax is less a problem for me than poorly organized code, poor grasp of problems and poorly thought out solutions. Design is a subtle and important topic that does not lend itself to the shorter coverage typical of internet material. Book-length immersion in the concepts is only a beginning to an understanding. So I think your "internet only" restriction is a severe constraint.

But it isn't as if there are many design books for beginners. These generally target people who've mastered some languages and know the design-problem space. "Pragmatic Programmer" was a big help.

I have found test-driven development an enormous help. It feels cumbersome, but you always know what problem you're trying to solve. "Test Driven JavaScript Development", Johansen, is an excellent overview of the approach. I'm also trying to work through Beck's "Test Driven Development By Example" doing the exercises in Ruby, but it's a side project that hasn't gotten much attention.

I repeat: I'm not a developer. Hopefully this is thought-provoking, but I'm no authority.

I read many tutorials and several books on TDD but never quite got it until I read Kent Beck's Test Driven Development By Example[1]. I also highly recommend his Screencast series on pragprog.com[2] which gives you a good flavour of the workflow he uses with TDD.

Edit: For those that don't know Kent Beck is basically the godfather of TDD.

[1] http://www.amazon.com/Test-Driven-Development-By-Example/dp/...

[2] http://pragprog.com/screencasts/v-kbtdd/test-driven-developm...

The same that that structural test creates unnecessary coupling there will be other tests that create that coupling as well. It is a learning phase. You will realize that there are things that you can do and things that you can't do while testing.

Once I learned how to test properly, TDD has been helpful, never a hindrance.

In case you haven't read them `Test Driven Development By Example` by Kent Beck and `Growing Object-Oriented Software Guided by Tests` by Steve Freeman and Nat Pryce are great books

Not sure if I'm qualified to appoint a cannon but I can tell you of the books that were very influential to me with regards to TDD:

Test-Driven Development by Example, Kent Beck. This came out in 2002 and I haven't read it since then but at the time it really influenced a lot of my TDD thinking. I expect if I read it now I'd have some complaints based on my decade of experience with the process.

Growing Object-Oriented Software, Guided by Tests, Freeman & Pryce. Much more recent and includes more modern thinking about TDD with acceptance/integration tests.

Working Effectively with Legacy Code, Michael Feathers. A great book for dealing with TDD when you aren't doing green field development. He is a bigger fan of Mock Objects than I am, but he illustrates some examples when mocking is the most appropriate response to the current requirements.

All that said, TDD is like any other software methodology. It is a set of patterns and principles that each practitioner interprets for themselves. At it's core though it's pretty simple, automatic verification of specifications are as important as implementation of the specification for any sufficiently long lived, complex software system. Writing those verifications first provides, design, process, and management advantages over the historical process of writing them last and has a high correlation with well factored code. That's it, no doctrines about unit vs integration tests, mocking out DB access or 100% code coverage.

TDD is designed for exactly the opposite. If you have a really good understanding of problem and solution from experience, then just go ahead and do it. Kent Beck talks about this in his book "Test Driven Development by Example".

TDD does best when you need to be able to respond quickly to new knowledge as you dive into the problem domain or make changes due to migrating business requirements. TDD lets you create your abstractions using concrete evidence, instead of trying to guess.

However, I have found TDD to be a difficult skill to master. You cannot just try it out for 6 months and expect to be quicker using TDD than you are without it. Until you have a bunch of experience built up in TDD, it will slow you down a great deal - which is what you may have experienced. It took me about 18 months of continuously using TDD daily to really get a solid grasp of TDD.

Test Driven Development by Kent Beck

http://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0...

Read:
The Pragmatic Programmer by Andrew Hunt & David Thomas
Code Complete 2 by Steve McConnell
Clean Code by James O. Coplien
Test Driven Development by Kent Beck (save this for last)

These books will teach you how to think and approach coding in a way that will make Object Oriented programming simpler to comprehend.

I can't suggest a book that explains basic OOP principals, hopefully some other much smarter person here can. I learned basic OOP through practice and through my education/class - but to be honest the basics are dead simple. It's only when you start getting into the very abstract that OOP starts to get really complicated and that's where the above books will help you.

"one of the best programming books ever written, and it barely has any code in it."

Sounds very fishy, but from Robert Martin, who thinks people who don't do TDD (not unit testing, TDD) are "unprofessional" and "stone age programmers", I wouldn't expect any less.

"He treats unit tests like mandatory rituals,"

cargo cult alert!

fwiw my conclusion based on my experience, unit tests are (by and large)a good idea. Test Driven Development is dubious, especially the "TDD is a design method" idea. Conflating the two notions isn't very useful but happens surprisingly often.

I personally think that test/behavior driven development is the way to go, so my advice will be geared in that direction. With that in mind, the "reference" text on it is probably "Test Driven Development: By Example" by Kent Beck. I've only skimmed it, myself, but it seems solid and Kent Beck is a smart guy.

The cool thing about testing (and TDD in particular) is that even introducing a bare minimum of that sort of discipline into your work consistent will quickly pay pretty big dividends. A quick way to get started is to read this Wikipedia article: http://en.wikipedia.org/wiki/Test-driven_development. Focus on understanding the TDD cycle. Mocks and stubs are useful to know, but you can safely consider them "advanced" and skip them if they confuse you initially.

Then, pick a test harness for your platform, say RSpec (http://rspec.rubyforge.org), if you're a Ruby person. Read the documentation and search for blogs and tutorial articles on the framework you've chosen. Then just start designing a simple module using it!

As you practice, you'll find it useful to read up on Mocks and Stubs and dig deeper into the philosophy and best practices. Dave Astels has some great writings out there.

Aside from using TDD for years, a few incredibly helpful tips I remember daily out of the book titled Test Driven Development: By Example, by Kent Beck:

Test lists - plan out a feature/system by listing out its tests. I do this in the form of behaviours and required inputs.

"Start small or not at all" - begin coding by doing the simplest super basic pieces first. You can then start the harder pieces last with a more informed complete understanding of the problem.

Edit: formatting

+1 to "Test-Driven Development: By Example" by Kent Beck. It won me over.

Anyone that wants to test in Python should really check out nose (nosetests). I made a slight modification to Django so that it gets run any time a change in code is detected in my project (i.e. whenever the development server restarts). So every time I make a code change, the tests run. Combining this feature with doctests makes testing a total breeze (and confidence booster).

I would agree with those two statements. They are even mentioned by Kent Beck, who created the technique in the first place, in his book Test Driven Development: By Example.

He spends a whole bunch of time hammering home the point that TDD is to help you manage complex problems and focus. He even mentions that if you think you can just power through the code and write it correctly in one swoop, then just do it. Skip TDD - it's not helping you then.

There are also other techniques he talks about regarding focus. For example, leaving a failing test as your last "bookmark" to where you left off for when you come back the next day. That allows you to jump right into where you left off, no ramp-up time at all.

Upvoted, and the book choices are as follows, but note that the response after submitting the request is something along the lines of: "Our team will review your request, and get back to you in a couple of days." (So I'm expecting coal in my stocking.)

Test-Driven Development with Python

iOS Game Development Cookbook

Java Performance: The Definitive Guide

Continuous Enterprise Development in Java

Clojure Cookbook

Mastering Perl, Second Edition

Mining the Social Web, Second Edition

Java Network Programming, Fourth Edition

Understanding and Using C Pointers

Embedded Android

ZeroMQ

Programming Android, Second Edition

Geolocation in iOS

Programming Computer Vision with Python

Safe C++

Python and AWS Cookbook