As others have said here, learning is never a waste of time. But, despite your post title, I think that's not what you're asking. You seem to be trying to figure out whether you should switch careers and whether it's realistic to think you can do so. First, you should ask yourself why you want to do this. You've said you love embedded, so I assume you think you'll find it's more engaging than QA and devops. You might take a moment to reflect upon your reasons though. Is it truly because you think it'll be more fun than what you're doing now? It is possible you feel that you've plateaued in your current position and you're hoping to change the trajectory of your career with a dramatic change to something you've enjoyed in the past? Are you hoping to make more money or have more control over your work? Do you dislike your boss?

Those questions might sound leading--as though I presume to know what you're really thinking. I don't, and they're just examples of where your head could possibly be at. It's important to question your motivation for changing careers because there might be a smarter, shorter path to getting what you truly want. For example, if you generally like QA/devops, but you're feeling like you're hitting a dead-end career-wise, you might first question whether there's a way to increase your trajectory while leveraging your six years of experience before changing direction. Maybe you could move to an area with a hotter devops scene where people are solving really tough infrastructure and scaling problems; where you'd suddenly have more senior mentors who've done some really cool stuff in your field.

But, let's assume you sort of fell into a QA/devops role and you're certain it's not your passion. In fact, you'd even be willing to take a pay cut to work on embedded projects. You should look around for local opportunities and see what's required. Here's the first entry-level position in Kentucky (Louisville--no clue if that's near you) that I found:
https://careers.geappliances.com/job/GEAPUS88/Software-Engineer-Embedded

It's asking for a BS in Electrical, Computer or Software Engineering or equivalent. Considering that they list it explicitly in this intermediate-level posting, I'm pretty sure they'll consider a Computer Science degree. Other than that, they pretty much just want you to know C (it sounds like you do, even if you're still learning), understand test-driven development (read this book), have a passion for software (sounds like you do), speak Mandarin (unless you do speak it, pick that as the one requirement you're allowed to ignore. GE is large and probably has a number of opportunities that could be a better fit), and have 1-5 years of experience of embedded development (which is where your time investment comes in through personal projects).

Sound attractive and tractable? Look around more and get comfortable with similar opportunities near you--or in areas to where you'd be willing to move. Spend some time shoring up your skills and completing some personal projects that you'd be proud to talk about in an interview. Your list of things you'd like to learn is a great place to start from. You shouldn't need to buy much equipment to get started. If you don't have access to an oscilloscope, pick up something like a Logic 4 for $110: https://www.saleae.com.

When you start applying, don't just blast your resume and a form letter to jobs email addresses. Spend some time on LinkedIn and see if you can get an introduction to a hiring manager. Regardless of whether you're addressing a contact via an introduction or a generic jobs email address, write a custom cover letter that explains why you're excited about the opportunity and how you can leverage your passion and your six years of experience in a different software tech industry. Pick out a few bullet points in the job posting and address them directly. Using the GE posting as an example, talk about how your QA experience has given you an understanding of how to write testable code; how you understand that build automation and automated testing are valuable; how you know exactly when to apply manual testing to things that are costly to automate. You love applying this knowledge along with your demonstrated passion for embedded engineering to build amazing, high-quality hardware products. You're excited because you've not seen many companies advertising continuous integration and test-driven development as part of their embedded development workflows; you think those are great practices for accelerating development, improving product quality, and responding to feature changes without regressing. Etc.

Whoops. Have to wrap up this tome and go walk the dog. Regardless of what you decide career-wise, if you love embedded work, you should most definitely keep it up as a hobby. Writing low-level code in C will give you a better understanding of your hardware, exposure to both good and terrible patterns, and an intuition for what higher-level languages might be doing under the hood. The diversity of experience will make you a better developer (and the same is true for, say, an embedded developer considering a project in Haskell).

Good luck.

Edit: spelling

I've posted this before but I'll repost it here:

Now in terms of the question that you ask in the title - this is what I recommend:

Job Interview Prep

1. Cracking the Coding Interview: 189 Programming Questions and Solutions
   
2. Programming Interviews Exposed: Coding Your Way Through the Interview
   
3. Introduction to Algorithms
   
4. The Algorithm Design Manual
   
5. Effective Java
   
6. Concurrent Programming in Java™: Design Principles and Pattern
   
7. Modern Operating Systems
   
8. Programming Pearls
   
9. Discrete Mathematics for Computer Scientists
   
   

   Junior Software Engineer Reading List
   

   
   

   Read This First
   

   
   

10. Pragmatic Thinking and Learning: Refactor Your Wetware
    
    

    Fundementals
    

    
    

11. Code Complete: A Practical Handbook of Software Construction
    
12. Software Estimation: Demystifying the Black Art
    
13. Software Engineering: A Practitioner's Approach
    
14. Refactoring: Improving the Design of Existing Code
    
15. Coder to Developer: Tools and Strategies for Delivering Your Software
    
16. Perfect Software: And Other Illusions about Testing
    
17. Getting Real: The Smarter, Faster, Easier Way to Build a Successful Web Application
    
    

    Understanding Professional Software Environments
    

    
    

18. Agile Software Development: The Cooperative Game
    
19. Software Project Survival Guide
    
20. The Best Software Writing I: Selected and Introduced by Joel Spolsky
    
21. Debugging the Development Process: Practical Strategies for Staying Focused, Hitting Ship Dates, and Building Solid Teams
    
22. Rapid Development: Taming Wild Software Schedules
    
23. Peopleware: Productive Projects and Teams
    
    

    Mentality
    

    
    

24. Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency
    
25. Against Method
    
26. The Passionate Programmer: Creating a Remarkable Career in Software Development
    
    

    History
    

    
    

27. The Mythical Man-Month: Essays on Software Engineering
    
28. Computing Calamities: Lessons Learned from Products, Projects, and Companies That Failed
    
29. The Deadline: A Novel About Project Management
    
    

    Mid Level Software Engineer Reading List
    

    
    

    Read This First
    

    
    

30. Personal Development for Smart People: The Conscious Pursuit of Personal Growth
    
    

    Fundementals
    

    
    

31. The Clean Coder: A Code of Conduct for Professional Programmers
    
32. Clean Code: A Handbook of Agile Software Craftsmanship
    
33. Solid Code
    
34. Code Craft: The Practice of Writing Excellent Code
    
35. Software Craftsmanship: The New Imperative
    
36. Writing Solid Code
    
    

    Software Design
    

    
    

37. Head First Design Patterns: A Brain-Friendly Guide
    
38. Design Patterns: Elements of Reusable Object-Oriented Software
    
39. Domain-Driven Design: Tackling Complexity in the Heart of Software
    
40. Domain-Driven Design Distilled
    
41. Design Patterns Explained: A New Perspective on Object-Oriented Design
    
42. Design Patterns in C# - Even though this is specific to C# the pattern can be used in any OO language.
    
43. Refactoring to Patterns
    
    

    Software Engineering Skill Sets
    

    
    

44. Building Microservices: Designing Fine-Grained Systems
    
45. Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools
    
46. NoEstimates: How To Measure Project Progress Without Estimating
    
47. Object-Oriented Software Construction
    
48. The Art of Software Testing
    
49. Release It!: Design and Deploy Production-Ready Software
    
50. Working Effectively with Legacy Code
    
51. Test Driven Development: By Example
    
    

    Databases
    

    
    

52. Database System Concepts
    
53. Database Management Systems
    
54. Foundation for Object / Relational Databases: The Third Manifesto
    
55. Refactoring Databases: Evolutionary Database Design
    
56. Data Access Patterns: Database Interactions in Object-Oriented Applications
    
    

    User Experience
    

    
    

57. Don't Make Me Think: A Common Sense Approach to Web Usability
    
58. The Design of Everyday Things
    
59. Programming Collective Intelligence: Building Smart Web 2.0 Applications
    
60. User Interface Design for Programmers
    
61. GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos
    
    

    Mentality
    

    
    

62. The Productive Programmer
    
63. Extreme Programming Explained: Embrace Change
    
64. Coders at Work: Reflections on the Craft of Programming
    
65. Facts and Fallacies of Software Engineering
    
    

    History
    

    
    

66. Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software
    
67. New Turning Omnibus: 66 Excursions in Computer Science
    
68. Hacker's Delight
    
69. The Alchemist
    
70. Masterminds of Programming: Conversations with the Creators of Major Programming Languages
    
71. The Information: A History, A Theory, A Flood
    
    

    Specialist Skills
    

    
    In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.
    
    

72. Peter Norton's Assembly Language Book for the IBM PC
    
73. Expert C Programming: Deep C Secrets
    
74. Enough Rope to Shoot Yourself in the Foot: Rules for C and C++ Programming
    
75. The C++ Programming Language
    
76. Effective C++: 55 Specific Ways to Improve Your Programs and Designs
    
77. More Effective C++: 35 New Ways to Improve Your Programs and Designs
    
78. More Effective C#: 50 Specific Ways to Improve Your C#
    
79. CLR via C#
    
80. Mr. Bunny's Big Cup o' Java
    
81. Thinking in Java
    
82. JUnit in Action
    
83. Functional Programming in Scala
    
84. The Art of Prolog: Advanced Programming Techniques
    
85. The Craft of Prolog
    
86. Programming Perl: Unmatched Power for Text Processing and Scripting
    
87. Dive into Python 3
    
88. why's (poignant) guide to Ruby

1. Yes, it is. Make sure you understand MVC which is quite similar. Model - View - Controller. MVC is essentially the future of ASP.Net application development. If you wish, you can delve into WebForms but it's effectively a dying technology (and good riddance)
   
   
2. I'd look at the following, they are pretty heravy so do take breaks, here and here. There are TONS of blog posts about ASP.Net security best practices, salting passwords, encryption etc.
   
   
3. The majority of .Net job offerings use ASP.Net in some capacity. The definitions of certain components will confuse you (Web API, MVC, WebForms, SignalR, I could go on...). It's WELL worth understanding this stack as you know, "The Internet is the future". I would recommend Steve Sanderson's book on MVC, it's not heavy and it actually goes through an application start to finish.
   
   
4. Most certainly, to be a modern developer and open to many career opportunities you will need to know JavaScript pretty well. Code School is fun and easy to use. It will teach you some quirks of JavaScript that you'll need to know. Always be aware that JQuery is not JavaScript. JQuery is an often used library.
   
   
5. Github is the best place for collaboration but you'll have to learn how to use Git (or use Windows Git or whatever the weird wrapper is called). Git and source control in general is important but might not be necessary to learn yet.
   
   My biggest piece of advice is to concentrate at one thing at a time, don't think "I have a great idea here for a web application, urgh, but what about security, what about scaling it!?" at your level, those problems are non-existent for you. Get the basic app running anywhere, then run through, security, scaling, testing, one thing at a time. It's only when you get to a senior level do you have to consider multiple things at one time and at the start of a project.
   
   Just remember, once you learn a language, it's behavior, it's syntax that's all that matters really. For every language. Frameworks and methodologies are easily learnt. The best thing is, once you learn one language, learning another becomes easier every time because most languages (like in the real world) have similar structures and syntax.
   
   Don't ever give up.
   
   As a sidenote, it's a good career to go down, I am mid-twenties and I earn more than both my parents combined and I am effectively my own boss, choose my own hours, wear what I want.
   

Oh wow, I just went down the rabbit hole of CPS, SSA, and ANF while developing my compiler for a strict Haskell-like functional programming language.

I read the outstanding book by Appel on compiling using CPS, and was all ready to go to refactor my pre-LLVM IR to be CPS. Then I did more research and realized that while a number of optimizations are very natural in CPS, compiling CPS to machine code is not as simple. It felt like a really daunting project, and after wrestling with my CPS transformations for about a week I filed a CPS IR away in the "research again someday" bucket.

The best intermediate representation for a functional language I've found is A-Normal Form (ANF). Here is the original paper on the subject. The argument goes that ANF is much more compact and easier to understand than CPS, and still enables almost all of the same optimizations. Some recent work with join points in GHC and a few other papers/theses I read (linked below) convinced me that ANF was going to be my choice of IR.

I highly recommend sticking with LLVM. It is a very mature ecosystem and it gives you so much "for free". I think it's neat that my optimization pipeline will look like:

1. Core -> Core optimizations
   
2. Some small ANF optimizations
   
3. Compilation to LLVM where I can have LLVM do some optimizations as well before spitting out machine code
   
   Even now, I only have some very rudimentary optimizations implemented for ANF, but turning on -O3 when compiling to LLVM makes my toy programs just as fast as equivalent programs I wrote in C. I feel like using LLVM gives you the best of both worlds between ANF and SSA; you hand-write your ANF transformations in your compiler, and let LLVM do the neat things that can be done with SSA optimizations. Note: I am no compiler expert. Maybe I'm being naive in thinking the LLVM optimizations after ANF optimizations give me that much. I'd be happy for someone else to chime in here :)
   
   Lastly, you mention ease of use and the ability to get started as important criteria. In that case something like ANF to LLVM is the obvious choice.
   
   Good luck!
   
   ---
   
   If anyone is interested, I gathered a lot of resources while researching CPS/ANF/SSA. I'll just dump them here:
   
   Andrew Appel wrote a book called Compiling with Continuations
   (https://www.amazon.com/Compiling-Continuations-Andrew-W-Appel/dp/052103311X),
   where he explains how continuations can be used as the back end of a compiler.
   Lots of stuff since then has been written on how using continuations makes lots
   of optimizations a lot simpler, and how it is pretty much equivalent to SSA.
   
   More stuff:
   
   

• SSA is Functional Programming:
  https://www.cs.indiana.edu/~achauhan/Teaching/B629/2006-Fall/CourseMaterial/1998-notices-appel-ssa_fnprog.pdf
  
• How to compile with continuations
  https://news.ycombinator.com/item?id=7150095
  
• Paper by Appel in 1988: Continuation Passing, Closure Passing Style
  ftp://ftp.cs.princeton.edu/techreports/1988/183.pdf
  
• Compiling with Continuations and LLVM:
  http://manticore.cs.uchicago.edu/papers/ml16-cwc-llvm.pdf
  
• Compiling without continuations:
  https://www.microsoft.com/en-us/research/wp-content/uploads/2016/11/compiling-without-continuations.pdf
  
• Compiling with Continuations, Continued:
  https://www.microsoft.com/en-us/research/wp-content/uploads/2007/10/compilingwithcontinuationscontinued.pdf
  
• Slides implementing Compiling with Continuations, Continued:
  http://code.ouroborus.net/fp-syd/past/2014/2014-08-Sloane-CPS.pdf
  
• Compiling with CPS (nice blog post using Haskell):
  https://jozefg.bitbucket.io/posts/2015-04-30-cps.html
  
  ANF and SSA resources:
  
  
• Original ANF paper: The Essence of Compiling with Continuations
  https://slang.soe.ucsc.edu/cormac/papers/pldi93.pdf
  
• Apparently the MLTon compiler used to use CPS but now uses SSA
  http://mlton.org/pipermail/mlton/2003-January/023054.html
  
• Comparing CPS, ANF, and SSA for compiling functional languages
  https://www.jantar.org/talks/zadarnowski03languages.pdf
  
• A Functional Perspective on SSA Optimisation Algorithms
  https://www.jantar.org/papers/chakravarty03perspective.pdf
  
• The CPS/ANF saga
  http://www.ccs.neu.edu/home/matthias/369-s10/Transcript/anf-vs-cps.pdf
  
• Thesis on optimizations with ANF: David Tarditi. Design and Implementation of
  Code Optimiziations for a Type-Directed Compiler for Standard ML. PhD thesis,
  School of Computer Science, Carnegie Mellon University, December 1996
  http://www.dtic.mil/dtic/tr/fulltext/u2/a326493.pdf
  
  • This is a great thesis.
    
  • It emphasizes a "pay as you go" compilation strategy where simple,
    monorphic code should not be slower simply because the language supports
    higher-level code.
    
  • Also, monomorphic functions should get specialized to machine-type
    functions.
    
  • C compilers focus on loops, so functional compilers should focus on
    recursive functions.
    
  • Explains lots of optimizations with a lambda calculus IR
    
• Paper summarizing the David Tarditi thesis
  https://pdfs.semanticscholar.org/55bc/5ceee768223f4b233de568a7181297eb2c4d.pdf
  
• A Correspondence between Continuation-Passing Style and Static Single
  Assignment. (IR'95, published as ACM SIGPLAN Notices, 3(30), March 1995)
  http://mumble.net/~kelsey/papers/cps-ssa.ps.gz

IMHO,

step 1: Read https://www.amazon.com/Pragmatic-Programmer-20th-Anniversary-2nd/dp/0135957052/ref=dp_ob_title_bk

step 2: Read https://realpython.com/python-pep8/ and https://docs.python-guide.org/dev/virtualenvs/

step 3: Write a REST API which takes arguments from the URL, uses these arguments to run some predictive model of your creation, and then returns the result; since you already know Python, I'd recommend using Flask, there are many free tutorials, just google it. If using Python, I highly recommend using PyCharm (the free community edition is enough) over Jupyter or Anaconda, the latter will let you do many bad things which would trigger a red warning in PyCharm (such us doing import in the middle of the file).

step 4 (optional, but recommended): Learn the basics of Java (this tutorial should be more than enough https://www.tutorialspoint.com/java/index.htm ) and read https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

step 5: Write a publisher application which reads a csv, xml, or json file from disk (for bonus points: from someone else's public REST API for data, for example https://developer.walmartlabs.com/docs/read/Search_API ), and turns the data contained within into a list of python dictionaries or serializable objects (btw, read up on serializing, it's important), and then sends the results into a kafka or rabbitMQ queue. I would strongly recommend sending each item/record as a separate queue message instead of sending them all as one huge message.

step 6: Learn how to use cron (for bonus points: Airflow) to make the application from step 5 automatically run every second day at 8 am

step 7: read the closest thing in existence to being the data engineering book: https://dataintensive.net/

step 8: Write a consumer application which runs 24/7 awaiting for something to appear in the queue, and when it does, it calls your rest api from step 2 using the data received from the queue, adds the returned result (predicted price, or whatever) to the data, then runs some validation / cleaning on the data, and saves it in some database (SQLite is the easiest to have running on your local computer) using an ORM (such as SQLalchemy).

step 9: Add error handling - your applications should not crash if they encounter a data-related exception (TypeError, IndexError, etc.) but instead write it to a log file (as a minimum, print it to the console) and continue running. External problems (connection to the database, for example) should trigger a retry - sleep(1) - retry cycle, and after let's say 5 retries if it's still dead, only then the application should crash.

step 10: For bonus points, add process monitoring - every time your application processes a piece of data, record what category it was in a timeseries database, such as influxdb. Install grafana and connect it to inlfuxdb to make a pretty real-time dashboard of your system in action. Whenever your application encounters a problem, record that in influxdb as well. Set grafana to send you an email alert whenever it records more than 10 errors in a minute.

Step 11: More bonus points, add caching to your application from step 2, preferably in Redis (there are libraries with helpful decorators for that, e.g. https://pythonhosted.org/Flask-Cache/ )

I'm assuming you are familiar with Spark, if not, then add that to your learning list. A recommended intro project would be to run some aggregation on a big dataset and record the results into a dedicated database table allowing for fast and easy lookup (typical batch computing task). You could also rewrite the applications from points 5 and/or 8 to use spark streaming.

I also heavily recommend learning how to use docker and kubernetes (minikube for local development), this is not only super useful professionally, but also makes it much easier to do stuff such as running spark and airflow on your home computer - downloading and running docker images is way easier than installing any of those from scratch the traditional way.

One crucial advice I can give is the mindset difference between data science and data engineering - unlike in data science, in data engineering you normally want to divide the process into as small units as possible - the ideal is to be processing just one [document / record / whatever word is appropriate to describe an atomic unit of your data] at a time. You of course process thousands of them per second, but each should be a separate full "cycle" of the system. This minimizes the impact of any crashes/problems and maximizes easy scalability¹. That is of course assuming that the aim is to do some sort of ETL, if you are running batch aggregations then that is of course not atomic.

¹ As an example, if your application from step 5 loaded all the data as one queue message, then the step 8 application would have to process it all in some giant loop, so to parallelize it you would have to get into multi-threaded programming, and trust me - you don't want that if you can avoid it (a great humorous tale on the topic http://thecodelesscode.com/case/121 ). You also have to run it all under one process, so you can't easily spread across multiple machines, and there is a risk that one error will crash the whole thing. If on the other hand you divide the data into the tiniest possible batches - just one item per message, then it's a breeze to scale it - all you need to do is to run more copies of the exact same application consuming from the same queue (queue systems support this use case very well, don't worry). Want to use all 8 CPU cores? Just run 8 instances of the consumer application. Have 3 machines sitting idle that you could use? Run a few instances of the application on each, no problem. Want the results really fast? Use serverless to run as many instances of your app as you have chunks of data and thus complete the job in an instant. One record unexpectedly had a string "it's secret!" in a float-only field and it made your app crash? No problem, you only lost that one record, the rest of your data is safe. Then you can sit back and watch your application work just fine while the colleague who decided to use multi-threading for his part is on his fifth day of overtime trying to debug it.

Hi, thank you. :)

You should learn C++ using C++ Primer by S. Lippman. (Not to be confused with C++ Primer Plus which was linked here before). Just be sure to learn modern C++, not "C with classes"! Then I recommend reading Effective C++ and Effective Modern C++ by Scott Meyers. Effective Modern C++ has some awesome examples of modern C++, but it also contains pretty hard edge-cases, so be aware of that.

The best way to learn Lua is by this book. It's very well written and I consider it to be not only the best book about Lua, but one of the best programming books ever!

Lua Users wiki is also very useful and contains lots of resources and sample code.

I also recommend checking out SFML Game Development book which is well written and contains some game programming patterns. You'll find it very useful even if you don't use SFML.

Oh, and Game Programming Patterns is a great read too.

___

Now, how much experience should you have with C++ to make games with it? That's a hard question! You should just start learning it and try making some small games with SFML or Corona. You'll see what you have to learn for yourself. :)

As you're both (you and the team) very new to scrum, you should start with some of the supporting basics that help tie everything together.

You're pretty far from the ideal situation, but there's nothing preventing you from learning and growing together. it's much harder without a careful guiding hand, but not impossible. There's a lot of things you're not going to know/understand simply because you haven't been exposed to it yet.

1. Always begin with why. Why do we have planning. Why do we have BL grooming. etc. by understanding the purpose of each ceremony you will be able to better understand how to execute these ceremonies against the context of your organization.
   
   IE: scrum doesn't have a set way to do these ceremonies (other than loose guidelines. the by-the-book approach) because how they are run is environment specific. Most places are not equipped to do scrum by-the-book exactly. IE: they have QA. and QA is not a role within the scrum framework. The team should clearly define the roles and responsibilities of each team member. These definitions will change over time through the retrospective. every standard, process, etc. should be treated the same way. you should always be verifying that your processes are still valid. As the team matures and grows their needs will change and your processes should reflect that.
   
   
2. The loose guidelines are a starting point. these are not an end-goal. IE: in the retrospective we typically ask three questions: What should we start doing, what should we keep doing, what should we stop doing. you answer these questions in the context of product (what you're working on), process, and people.
   
   However this is a 'crutch' for teams that don't understand the retro yet. this format should eventually change, but you won't have to worry about this for a while.
   
   
3. do everything you can to understand the basics of software development. (IE: things that should be done independently of Scrum) These are things like understanding the 5 levels of estimation, the difference between relative and absolute estimations, why the team needs to establish standards for processes and definitions (IE: definition of done, when should something be a task vs a story), the difference between data and information, roles and responsibilities, etc.
   
   This is the kind of stuff that really differentiates between a scrum master/agile coach and a project manager.
   
   
4. Also understand that Scrum is an agile framework. Just like the 3 question approach to the retrospective, scrum is a stepping stone to becoming agile. If you haven't, you should read the original HBR article about scrum to get a better understanding of the strengths and weaknesses of the framework. this should help you understand the 'why' behind each ceremony and allow you to better make adjustments based on your environment.
   
   6 months to a year from now, what you're doing should look different than scrum by-the-book. I highly recommend you start reading books to help cover the gaps in your understanding. I suggest you start with Phoenix Project and a book on writing user stories.
   
   
5. Think of scrum as a problem finding mechanism and not a problem solving mechanism. This is why the retrospective is the most critical ceremony of scrum. DO NOT WORK AROUND PAIN POINTS. If the team says they feel like they have too many meetings, figure out why. If something took longer than expected, dig into what dependencies were missed in planning and take steps to make sure those aren't forgotten again.
   
   The point of a sprint is to iterate. Yes, we also get shippable increments out of a sprint and that's important, but this pales in comparison to iterating against your product (so you can fail faster and get more value to your customer) and your own development process (this is what will truly enable you to iterate faster and faster as you mature)
   
   This means you will often but heads with leadership, as better development practices often require a shift in culture. Ultimately you want to be able to have autonomous teams that are aligned to the business needs.
   
   -----------------------
   
   Recomended reading:
   
   https://hbr.org/1986/01/the-new-new-product-development-game
   
   https://www.amazon.com/Phoenix-Project-DevOps-Helping-Business/dp/0988262509
   
   https://www.amazon.com/User-Story-Mapping-Discover-Product/dp/1491904909/
   
   https://www.amazon.com/User-Stories-Applied-Software-Development/dp/0321205685/
   
   https://www.mountaingoatsoftware.com/blog
   

> Can anyone please recommend a good guide or book to start with?

If you already have a little sophistication, you could do a heck of a lot worse than Dive Into Python. You could buy it, if you'd like, but it's also available free under a permissive license. Beginning Python is also very good, not too expensive. It's best when hand-holding you through a few somewhat-interesting projects near the end.

> Also i heard of Python 3 on reddit, do i really need it to start with python, or should i just go with a bit older version till the 3rd one is sorted out?

Stick with 2.6 for now. It'll take a while for Python 3 to accumulate compatible libraries or significant developer mindshare.

> I have an Ubuntu box in which i do my programming, so please if you can recommend a compiler and editor for Ubuntu too.

Well, like wallish said, just get Python from apt-get. As for editor? I use emacs, which has terrific Python support. But, uh. If you're looking for something a little slicker out-of-the-box you could try Komodo Edit. Eclipse and NetBeans both have Python editing capabilities now, but I don't think they're built in just yet.

Pretty much any editor you come across will have Python syntax highlighting, at the very least. Something with debugging will be a little harder to come by. The nice thing about Emacs is you can (with just a little work) get code completion, debugging, an interactive shell, etc.

Yeah man, Haybro is right. I would say learn c# first, since you don't have to worry about memory management as much (though don't forget about it :) ). There is a check list I go through for c# and it is as follows:

• understanding different basic data types (ints, floats, bool, string) and how to manipulate them (especially strings)
  
• understanding the difference between properties and fields.
  
• If and switch statements
  
• Ternaray Operators
  
• Basic Mathematical Operators (*, +, =, etc);
  
• understand the difference between = and ==, and not operators (!(true) and !=)
  
• Advanced Mathematical Operators (+=, % for modulus , << left bit shift operator)
  
• Arrays and Lists
  
• Dictionaries and Keypairs
  
• Understanding objects, classes and constructors
  
• New Keyword
  
• Access Modifiers and Static
  
• Understanding references and null values
  
• Inheritance
  
• Indexers
  
• Namespaces and using
  
• Partial Keyword and why it's a good idea to limit the use of it
  
• Abstract classes and interfaces
  
• Delegates, Events, Action and Func
  
• Understanding generics and using <T>.
  
• Casting types with 'as' or direct and understanding the difference
  
• Serialization
  
• Comments and Regions
  
• Threading
  
• ref and out keywords and why they can be bad to use
  
• IEnumerable and Yield Return
  
• Enums and flags
  
• Understanding Loops (while, foreach, for and do) and the differences between all of them
  
• continue and break keywords and how to use them in loops
  
• try,catch and finally
  
• Understanding methods: void, return types and parameters
  
• overloading methods
  
• Knowing what the params keyword is and how to use it in methods
  
• what virtual and override are and how they can be used
  
  I found this tutorial series to be very good (although it doesn't focus on game development which is a shame).
  
  Once you have these fundamentals, the you can start programming in a game engine (personal I like unity because there are a ton of tutorials out there for it :) ).
  
  After you have got confident with using Unity and c#, you'll probably want to start learning about design patterns and decoupling techniques. [This free online book] (http://gameprogrammingpatterns.com/) is amazing, and I would recommend it to everyone:).
  
  Other books like Clean Code and The Art of Unit Testing have helped me a lot too.
  
  With coding, it because more about creating code that is easy to change. At the moment, I am looking into using StrangIoc along with MVC to achieve decoupled, clean code:).
  
  Hope all this helps man.

1.) Treat your employees (every single one of them, no matter their position or seniority) with the same amount of respect. Most employees really want to be excited about coming to work, enjoy their job and have their contributions and ideas valued. Try to cultivate that type of environment. I'm not saying to bust out pizza parties and loosen the dress code, because I know work still needs to get done, but "work" and "fun" are not mutually exclusive.

2.) The managers that I've looked up to the most, are the ones who constantly ask: "What do you guys think?" I remember one specific manager at Hewlett Packard who took a very hands-off approach. (We had a good team there and honestly didnt need much managerial oversight because we rocked). Your employees are smart, they are in the trenches (so to speak) every day. Give them some autonomy over their own work and encourage them to work well together as a team.

3.) Find and read Bill Swanson's 25 Unwritten Rules of Management I've got an original copy of the spiral bound mini-book and its really good. Simple, straight to the point, pragmatic.

4.) Find and read Joel Spolsky's "Joel On Software"

5.) Don't make important decisions as a singular individual and then force them down onto the teams, especially in situations where employees might resent or actively fight (work around) the intended results. If you even see a hint of that happening, talk and work with your employees to find out what exactly they dont like, or think is a bad idea. Many times (as long as the conversation is positive and productive) you can find a better solution, find a way to minimize the negative impacts, or at the very least simply help your employees understand WHY the decision was made. Keep them on your side.

> I don't think you've actually used any of the modern Lisps.

Not true. You'll find my name in the acknowledgements of Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp. My "Road to Lisp Survey" page is here.

> Common Lisp has CLOS (a ridiculously powerful object system)...

That's a definite plus for Common Lisp, IMHO.

> most Schemes have their own object systems.

Yes, but they aren't standard.

> In addition, there is no Lisp that ships without stuff like hash tables, arrays, structs, etc.

On the contrary; most Schemes ship without them.

> The reason textbooks build this basic stuff from scratch is because they need to demonstrate how you can build complex systems using simple abstractions.

In the cases I'm referring to, that's not the reason at all. The reason is they want to be able to manipulate abstract syntax trees in the obvious way: as sum types. So they simulate the minimum functionality of sum types they need. There's nothing wrong with that per se; it's just unnecessary in languages that already support sum types (and much, much more). Granted, the authors may be well aware of this and chose to use Lisp in their texts so as not to have to explain sum types in a text that's supposed to be about implementing programming languages rather than using one to do so, but it's not obvious that that's a win; see Modern Compiler Implementation in ML for a counterexample.

> If you want to use Lisp for actual production work, I suggest you ditch SICP and pick up something like Practical Common Lisp. If you want to stick with Scheme, the Racket documentation should be more than adequate.

Practical Common Lisp is indeed brilliant. Racket is a wonderful Scheme (and much, much more) implementation. But I've long since moved beyond Lisp.

> Also, obligatory QuickLisp mention. It'll change your life.

For folks who haven't yet tried Common Lisp and want to get going in a hurry, that's absolutely correct.

> Delimited continuations are better than undelimeted (as I have read)

I wouldn't say they are better, but they are different in small ways. Delimited continuations are more complex, but with that complexity comes a notion of scope. Depending on what you're doing, that extra capability may or may not be better (okay, so usually it's better in real programs). So if you're designing a language or library that implements continuations you still have a trade-off between the added complexity of delimited continuations vs undelimited continuations.

Have you seen Andrew Appel's book "Compiling with Continuations"? I have not read it personally, but my understanding is that it is highly relevant to your question. Perhaps you can find an online preview to see if it would help you.

I think you would benefit a lot from "wrapping up" your continuations in a computation expression. In Haskell land, they have a continuation monad and it makes writing things in terms of continuations more convenient. For instance, here is an article meant to introduce beginning Haskell programmers to the Cont monad: https://wiki.haskell.org/All_About_Monads#The_Continuation_monad

The idea is that you create a continuation at each lexical point you may want (or need) to return to (say for instance, you want to return to the top level of the interpreter when you detect a division by zero). Creating the continuation gives you the 'escape hatch' that you may call later in the exceptional case. I think the haskell example makes this clear by calling the continuations "exit1" and "exit2".

I hope that helps.

Before anything else, there's a great book that helps with this whole thing: Agile Estimating and Planning

Next, there are lots of other approaches, and based on how you're explaining your understanding on the three methods you offered (and the benchmark example especially), I think you might find some clarity in reading through these resources:

8 Agile Estimation Techniques Beyond Planning Poker - I think this will help the team wrap their heads around what's being asked in expressing estimates with storypoints.

Fast Estimation - really good technique that cuts through the noise.

Agile Project Estimation Techniques from PMI- because of your questions relating to release intervals, I think reading through this article that goes into detail about some of the techniques already mentioned may simplify your thinking on this, especially the section on "Determining Budget".


Finally, answers to your specific questions:

1. Yes, I worked with a team that did this. They had a good understanding of the needs of their qa team and were conscientious about documentation and smooth code review protocol, so that helped a lot. If something would take more than the available hours in a sprint, they'd break it down further to discrete work parts. They did move away from it after they had a better concept of capacity and velocity as expressed in story points. I think they were an exception, rather than the rule, however, and for most any other team I'd likely recommend entirely different approaches, since it's easy to get bogged down in the translation.
   
   
2. You would take a new benchmark story. Partly because as the team gets more mature, something estimated at 3pts at one point in time would now maybe be 2, and partly because effort needs to be evaluated in context, so an older work item would have staled in relevance.
   
   
3. This is more of a learning to estimate technique than one that would stay in the team's toolbox forever, maybe to get pulled out again in the future to break down particularly sticky specs/reqs. At least one of the articles above discusses this method in detail, perhaps making it easier to decide if it's worth using.

Meetings. Lots of meetings. My main responsibility is to analyze the business process for a particular aspect of a company's operations and see how IT systems can improve it. So I'll first interview a number of employees, from worker bees to executives. Then create diagrams and data models to document the abstract and functional business process. Finally I work with the development teams to design the IT system supporting that process. You have to enjoy figuring out how things work, getting into the details of what data gets passed around. Also meeting facilitation, a lot of group discussions on how to improve things. I started as a developer, moved to architect, then requirements gathering, and combined all that into becoming a Business architect. The most valuable skill I bring is an ability to gather and understand how both IT systems work and how business processes work. I mostly specialize in commerce, order management, and payment systems.

A lot of my job is relationships. Meeting people on the business and asking what they hate about how something works. Being interested in a developer's baby they created and how it works. Always asking questions and documenting. A lot of 30 minute conversations at happy hour result in a user story that saves a person hours of time at their job.

One tip I give all my BA's is don't just know what your system is supposed to do. Also learn how the other systems work too. When you know how all the other systems work, you can better understand how to fit your software into the overall ecosystem. You also are building those relationships to other development teams that come in very handy later.

Here's my favorite book on writing user stories to get you started. User Stories Applied: For Agile Software Development

Anthony Sotille is a pytest core contributor, as well as a maintainer and contributor to many other projects. In this episode, Anthony shares some of the super cool features of pytest that have been added since he started using it. We also discuss Anthony's move from user to contributor, and how others can help with the pytest project.Special Guest: Anthony Sottile.Sponsored By:Azure Pipelines: Many organizations and open source projects are using Azure Pipelines already. Get started for free at azure.com/pipelinesSupport Test & Code - Python Testing & DevelopmentLinks:pytest documentationpytest Changelogpytest API Referencesponsor pytestgetting started contributing to pytestthe book: Python Testing with pytest — The fastest way to learn pytest<p>Anthony Sotille is a pytest core contributor, as well as a maintainer and contributor to <br> many other projects. In this episode, Anthony shares some of the super cool features of pytest that have been added since he started using it.</p> <p>We also discuss Anthony's move from user to contributor, and how others can help with the pytest project.</p><p>Special Guest: Anthony Sottile.</p><p>Sponsored By:</p><ul><li><a href="https://azure.com/pipelines" rel="nofollow">Azure Pipelines</a>: <a href="https://azure.com/pipelines" rel="nofollow">Many organizations and open source projects are using Azure Pipelines already. Get started for free at azure.com/pipelines</a></li></ul><p><a href="https://www.patreon.com/testpodcast" rel="payment">Support Test & Code - Python Testing & Development</a></p><p>Links:</p><ul><li><a href="https://pytest.org/en/latest/" title="pytest documentation" rel="nofollow">pytest documentation</a></li><li><a href="http://doc.pytest.org/en/latest/changelog.html" title="pytest Changelog" rel="nofollow">pytest Changelog</a></li><li><a href="http://doc.pytest.org/en/latest/reference.html#" title="pytest API Reference" rel="nofollow">pytest API Reference</a></li><li><a href="https://docs.pytest.org/en/latest/sponsor.html" title="sponsor pytest" rel="nofollow">sponsor pytest</a></li><li><a href="http://doc.pytest.org/en/latest/contributing.html" title="getting started contributing to pytest" rel="nofollow">getting started contributing to pytest</a></li><li><a href="https://amzn.to/2QnzvUv" title="the book: Python Testing with pytest" rel="nofollow">the book: Python Testing with pytest</a> — The fastest way to learn pytest</li></ul>

The role of the product owner is a little tricky because there isn't a lot in the scrum guide that tells you how to do the tasks required. A lot of these tasks happen outside the sprint and touch on Agile Project (or product) Management and lives in the realm of Business Analysis. Of course communication with an emphasis on listening carefully is going to be the key skill.

Requirements analysis or requirements engineering is the process that you seem to be looking to define. Searching on either of those terms may prove better results for templates or techniques. That's the process of determining the user needs / wants / expectations and turning those into features.

The first step that I find important is to ensure that the PO has a clear vision of the product. By this I don't mean the details of how it will function but what is the domain the product lives in and what problems it's trying to solve, basically the why of the product.

There are several techniques that can help to define this. Some people like the Business model canvas or the lean canvas filling those even partially with stakeholders can help to define the vision.

Another technique is a version of the Product Box Game that you can do with your stakeholders to help define the features of the product. Imagine what emotional is portrayed by the box's artwork and what features are prominent on the front, what secondary features are detailed on the back.

Books that may assist are User story mapping and the techniques described in there are basically what SCRUM requires.

In the past I have also used some of the techniques in the Rational Unified Process to get a sense of the types of questions that should be asked. I don't want to put too much emphasis on that because I really don't recommend following RUP because it's way too bloated (way more than SCRUM) however, one could easily skim some of those such as the Elicit Stakeholder Requests or the idea of Capturing a Common Vocabulary can be helpful as some people use terms very differently. I don't really want to link to that because I really don't recommend that process but if someone asks I'll link it.

TL;DR check out this video, Product Owner in a Nutshell

I learned from a book, Beginning Python. I would also recommend something with specific examples of bioinformatics problems, like Python for Bioinformatics, but there are examples for Perl out as well if you prefer that route. Python has a lot of libraries specifically for science and math, so it may be a slightly more flexible choice however. Unless you really like C, or the course will use a lot of it, I may stay away from it until it comes up in a course. Its much trickier getting something biologically useful up and running from a beginners standpoint.

Edit: It looks like the program you are going to is pretty Perl heavy, so I would start there. Maybe just play around with some of the Beginning Perl for Bioinformatics modules, or something like it. Start with learning how to do translation tables and maybe mine for palindromic sequences, your courses will build from stuff like that and how the file formats are structured.

I concur with learning a programming language, however I disagree with learning python, not that isn't a bad idea to learn it, but for automation I would suggest ruby actually....as a lot of the automated testing uses ruby (or ruby on the backend)...it's a pretty easy language to learn.

Automation is HOT right now, literally I get people adding me on linkedin JUST because I put "automation" or "selenium" on there. It's crazy at how in demand it is.

It's actually really not that bad to learn either, my programming is Rusty (I also graduated with a CS degree like 7 years ago) so you probably still have the "ability" to pick it back up easily.

I'd also suggest this book on agile testing : https://www.amazon.com/Agile-Testing-Practical-Guide-Testers/dp/0321534468
It's a pretty well-known and referenced book.

As for Automation i'd suggest trying it out on an External Site and using Capybara with Selenium AND Poltergeist drivers. Capybara is a DSL and helps sort of...shorten the commands needed per driver (Such as click_button in all Drivers as opposed to using Seleniums driver specific button clicking method).

Poltergeist is a headless driver that uses Phantomjs, so it's perfect for Continuous Integration (Recruiters love that word). So it's worth learning to say you know how to write automated tests for a CI environment.

If you have any questions on automation let me know, I do it everyday as a QA where I work.

The manifesto principles are about the best you can do as for an 'official' set of rules : http://agilemanifesto.org/principles.html - most importantly, the last point about:

\> At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

Everything else comes from there - the team learns what works best for them. However, if you want a glimpse into why teams do certain things, I'd really encourage you to read https://www.amazon.co.uk/Lean-Software-Development-Agile-Toolkit/dp/0321150783 It might appear a bit dated - but in practice the ideas around feedback and waste are very useful lenses in which to evaluate any particular implementation of 'agile' and how to improve whatever it is the team is currently doing.


As for full-stack developers, my opinion is that it's about being able to have empathy in the various individuals for different considerations - the business objectives, UX, front-end practicalities, backend, architecture, operations and so on. That doesn't preclude very separated roles but as an example: if everyone knows what direction we should take the product, why have a product manager? If people can do operations, why have a sys-admin-type person? If the front-end devs can do back-end too, why have back-end devs? There's answers to all of these questions - but they're different for each team.


Consider a 1-person team working on a product by themselves. Imagine they were somehow successfully making money and could hire one more person - do they actually need an extra person? What would they want that extra person to do that would help them grow the most? If they were previously doing everything, they might actually just need someone to go sell the product they've made, or someone to handle meetings with stakeholders and gather data about what to work on next, rather than another developer, and so on. It might just be that they want someone to share everything 50:50.

Interesting!

Looks to me that you can "feel" what good code looks like but you're not able to rationalise it enough for you to write it on your own.

Couple of suggestions:

When you see elegant code, ask yourself: why is it elegant? Is it because is simple? Easy to understand? Try to recognise the desired attributes so you can try to reproduce on your code.

Try to write really short classes/methods that have only one responsibility. For more about this, search for Single Responsibility Principle.

How familiar are you with unit testing and TDD? It should help you a lot to write better designed code.

Some other resources:

• Uncle Bob's SOLID
  
• Clean Code
  
• TDD by Example
  
• The Art of Unit Testing
  
• Refactoring
  
• Domain-Driven Design
  
• Patterns of Enterprise Application Architecture

It's never too early to familiarize yourself with best and current practices within the field.

I'm not sure what your financial situation is as a student, but I would start by locating and getting in contact with the IIBA or PMI local chapter closest to your home or university. It is an invaluable way to build your professional network, discuss the field, and listen to lectures and presentations built on real world experience.

There are also a number of websites which have useful information about the field (white papers, articles, etc.):

• BA Times
  
  
• Modern Analyst
  
  
• Bridging the Gap
  
  
• Mastering Business Analysis - Dave Saboe also hosts a great podcast of the same name
  
  If you are inclined to purchase books, I've found the following very useful in my career:
  
  
• Software Requirements 3rd edition
  
  
• User Stories Applied: For Agile Software Development
  
  
• User Story Mapping
  
  I would say start with the free websites, immerse yourself in the culture/field and take in all you can. Participate in the r/BusinessAnalysis forum. Finally, network your butt off get a job and start your career.
  
  If you have any other questions feel free to ask or PM me.
  

Here's my list of the classics:

General Computing

• But How Do It Know? - The Basic Principles of Computers for Everyone
  
  
• The Elements of Computing Systems: Building a Modern Computer from First Principles
  
  
• Code: The Hidden Language of Computer Hardware and Software
  
  
• Gödel, Escher, Bach: An Eternal Golden Braid
  
  Computer Science
  
  
• The New Turing Omnibus: Sixty-Six Excursions in Computer Science
  
  
• Compilers: Principles, Techniques, and Tools, 2nd Edition (aka The Dragon Book)
  
  
• The Art of Computer Programming
  
  
• Algorithms, 4th Edition
  
  
• Introduction to Algorithms, 3rd Edition (aka CLRS)
  
  
• Essential Algorithms: A Practical Approach to Computer Algorithms Using Python and C#, 2nd Edition
  
  
• Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People
  
  
• Structure and Interpretation of Computer Programs, 2nd Edition (aka SICP, available for free on the MIT website)
  
  
• Discrete Mathematics with Applications, 4th Edition
  
  Software Development
  
  
• Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems by Martin Kleppmann
  
  
• Design Patterns: Elements of Reusable Object-Oriented Software (aka The Gang of Four)
  
  
• Think Like a Programmer: An Introduction to Creative Problem Solving
  
  
• The Pragmatic Programmer: your journey to mastery, 20th Anniversary Edition, 2nd Edition
  
  
• The Mythical Man-Month: Essays on Software Engineering
  
  
• Code Complete: A Practical Handbook of Software Construction, 2nd Edition
  
  
• The Design of Everyday Things
  
  
• Clean Code: A Handbook of Agile Software Craftsmanship
  
  
• Programming Pearls, 2nd Edition
  
  
• Soft Skills: The Software Developer's Life Manual
  
  
• Hello, Startup: A Programmer's Guide to Building Products, Technologies, and Teams
  
  
• Hacker's Delight, 2nd Edition
  
  
• Peopleware: Productive Projects and Teams, 3rd Edition
  
  Case Studies
  
  
• The Soul of a New Machine
  
  
• Masters of Doom: How Two Guys Created an Empire and Transformed Pop Culture
  
  
• Hackers: Heroes of the Computer Revolution
  
  
• Where Wizards Stay Up Late: The Origins Of The Internet
  
  
• Fire in the Valley: The Birth and Death of the Personal Computer, 3rd Edition
  
  Employment
  
  
• Cracking the Coding Interview: 189 Programming Questions and Solutions, 6th Edition
  
  
• The Complete Software Developer's Career Guide: How to Learn Programming Languages Quickly, Ace Your Programming Interview, and Land Your Software Developer Dream Job
  
  
• The Self-Taught Programmer: The Definitive Guide to Programming Professionally
  
  
• The Passionate Programmer: Creating a Remarkable Career in Software Development
  
  Language-Specific
  
  C
  
  
• The C Programming Language, 2nd Edition
  
  Python
  
  
• Automate the Boring Stuff with Python: Practical Programming for Total Beginners, 2nd Edition
  
  
• Python Crash Course: A Hands-On, Project-Based Introduction to Programming
  
  
• Python Programming: An Introduction to Computer Science, 3rd Edition
  
  
• Effective Python: 59 Specific Ways to Write Better Python
  
  C#
  
  
• The C# Player's Guide, 3rd Edition
  
  C++
  
  
• The C++ Programming Language, 4th Edition
  
  
• Starting Out with C++: from Control Structures to Objects, 9th Edition
  
  Java
  
  
• Introduction to Java Programming and Data Structures: Comprehensive Version, 11th Edition
  
  
• [Java: A Beginner's Guide](https://www.amazon.com/Java-Beginners-Seventh-Herbert-Schildt/dp/1259589315/, 7th Edition)
  
  
• Java: The Complete Reference, 11th Edition
  
  
• Core Java Volume I - Fundamentals, 11th Edition
  
  
• Starting Out with Java: From Control Structures through Objects, 6th Edition
  
  
• Effective Java, 3rd Edition
  
  Linux Shell Scripts
  
  
• The Linux Command Line: A Complete Introduction, 2nd Edition
  
  
• Wicked Cool Shell Scripts: 101 Scripts for Linux, OS X, and UNIX Systems, 2nd Edition
  
  
• Linux Command Line and Shell Scripting Bible
  
  
• Mastering Linux Shell Scripting
  
  Web Development
  
  
• Learning Web Design: A Beginner's Guide to HTML, CSS, JavaScript, and Web Graphics, 5th Edition
  
  
• Eloquent JavaScript: A Modern Introduction to Programming, 3rd Edition (also available for free on the author's website)
  
  
• JavaScript and JQuery: Interactive Front-End Web Development
  
  
• HTML and CSS: Design and Build Websites
  
  
• You Don't Know JS: Up & Going
  
  Ruby and Rails
  
  
• Ruby on Rails Tutorial: Learn Web Development with Rails, 4th Edition (Note: this book is somewhat out of date compared to the live version on the author's website.)
  
  
• The Well Grounded Rubyist, 3rd Edition
  
  
• Practical Object-Oriented Design in Ruby: An Agile Primer
  
  
• Agile Web Development with Rails 5.1
  
  
• Programming Ruby 1.9 & 2.0: The Pragmatic Programmers' Guide, 4th Edition
  
  
• Eloquent Ruby
  
  Assembly
  
  
• Assembly Language for x86 Processors, 8th Edition

Hey, fellow QA!

I got started as a QA Engineer about 6 years ago, and if you work in a studio where they use agile for managing their projects, I'd Recommend Agile Testing as a good book to get in the right mindset for handling QA tasks. The book is half an intro to Agile, and half how you can make the most of your QA position for the team.

Apart from that, I'd suggest reading up on automated testing frameworks. Microsoft CodedUI, Selenium, and scripting for programs like SOAPUI/Jmeter are great places to start. If you're considering staying in QA for the long term like me, having Automation experience gives you "expert" skillsets that really help your resume/salary potential.

If you've got any other questions about QA, feel free to ask! I've done a fair amount of freelance testing for games, and I'm currently working in enterprise software. Job market is much better for that where I live.

These are great suggestions. The three books I typically give devs early (that fit in well with the two presented here) are:

Refactoring by Martin Fowler

This is a list of patterns of common refactoring a and how to do them safely. It’ll help you recognize transforms you need to make in your code as it changes.

The Pragmatic Programmer by Dave Thomas and Andy Hunt

This is a great guidebook for how to get better at being a software engineer. Essential read.

And while there are lots of options for design patterns books...

Head First Design Patterns was the one that helped me internalize them. Even if you aren’t writing much (or any) Java, the method of teaching is hugely valuable.

See the Proggit FAQ I'm not a programmer. How do I start?.

I'm not a programmer (I like "Data Munger" as a descriptor) so take what I say with caution. I like Python, I use it as a tool to automate tedious data-munging tasks as well as for toy programs. I also use shell and Ruby but I never have the need for the speed gains from Java, C etc. Mark Pilgrim's Dive In To Python is a great book on Python (and he has an updated book for Python 3, Dive into Python 3). Magnus' book Beginning Python: From Novice to Professional is also an excellent book and I know some Python hackers who think it's one of the best out there.

As @OrangePlus suggests the amount of online resources are enormous.

Cool :)

I would start with CD book https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912

Having read it you would understand how modern software development look like and you should understand why test automation is crucial these days.

I had once created a post about learning test automation - you can check it here
http://www.awesome-testing.com/2016/08/how-to-start-learning-test-automation.html

Here are two paths I proposed:

Path 1 - GUI Automation with Selenium

1. Learn basics of programming language first - preferably with Java for Testers book.
   
2. Learn basics of Selenium - preferably with Guru99 Selenium course.
   
3. Start writing real tests on existing website, for example http://the-internet.herokuapp.com/
   
4. Make sure you understand how Maven/Gradle, TestNG/Junit work.
   
   Path 2 - REST API Automation with Rest-Assured
   
   
5. Learn basics of programming language first - preferably with Java for Testers book
   
6. Learn HTTP protocol with HTTP: The definitive guide
   
7. Learn about REST API - Microsoft has recently published it's API Guide with useful links
   
8. Learn Rest-Assured with Baeldung, Test Detective or some different guide (there is plenty of them)
   
9. Write tests against real API. Check my post which you can use as a reference.
   
10. Make sure you understand how Maven/Gradle, TestNG/Junit work.
    
    There are a couple of testing books which are worth reading too. Perhaps this one is the best https://www.amazon.com/Agile-Testing-Practical-Guide-Testers/dp/0321534468
    
    Just start small with basic checks. You may even use my github project https://github.com/slawekradzyminski/AwesomeTesting
    
    Hope I hadn't overwhelmed you :D
    

Perl isn't that bad TBH. Yes it's easy to write obfuscated code - but it's equally easy to write clear code. "There's more than one way to do it!".

https://perlmaven.com

and

https://www.perlmonks.org

...are both great resources for learning perl.

I mostly used the Camel Book though.

Once you're familiar with the regex syntax, you'll wonder how you ever survived without it. You can even ditch awk and sed and use perl -pi -e instead. I have this aliased to 'ppie' and use it all the time!

10000 limit again. Reserving this comment for the Programming section:

PROGRAMMING
Gray Hat Python: Python Programming for Hackers and Reverse Engineers
Beginning Python
The Python Standard Library by Example (Developer's Library)
Shell Scripting
Shell Scripting Recipes: A Problem-Solution Approach
Linux Command Line and Shell Scripting Bible, Second Edition
Wicked Cool Shell Scripts
sed & awk (2nd Edition)
The Ruby Programming Language
Beginning Ruby: From Novice to Professional
Ruby on Rails 3 Tutorial: Learn Rails by Example
Agile Web Development with Rails
Automating Microsoft Windows Server 2008 R2 with Windows PowerShell 2.0
Pragmatic Guide to Subversion
Programming Perl
C++ Primer Plus
The AWK Programming Language thanks sjhill
Modern Perl thanks three18ti
High-Order Perl thanks three18ti
The Art of Scalability thanks mr_chip
Scalability Rules thanks mr_chip
Continuous Delivery thanks mr_chip
The Varnish Book thanks mr_chip

It seems that most introductory texts focus on parsing. However, in my experience, the dragon book does a good job on introductory code generation. Appel's Tiger Book had good information as well. As a heads up, the C and Java versions of the same book are done as an afterthought, and you can tell that the code was translated after the fact. Stick with the ML version.

For optimization algorithms, I've heard good (And bad) things about Muchhnik: Advanced Compiler Design and Implementation.

However, I've had better luck just reading various papers. If there's a specific part of code generation and emission, I can point you to plenty of good papers.

Prior to January, I knew nothing about C#, ASP.NET or webdesign. I did have some experience with Java, which obviously came in handy.

Right now I have no issue using ASP.NET MVC 4 to create the website I want. This was my personal experience, but I consider these 10 videos sacred. Definitely go trough them, they're entirely worth it.

I've also bought the book Pro ASP.NET MVC 4, definitely a solid choice as well. The first few chapters give you a detailed explanation of MVC and everything surrounding this design, then you've got a few chapters where you create an example application, followed with a big amount of chapters where everything is explained in depth. I'm still working trough this, but I can already tell you it's a very good book.

> By the way: scrum does not assume deadlines. They refined their wording from commitment to forecast in 2011 to make it clear that the sprint output is not based on a fixed scope.

Scrum can be done with or without deadlines. The scrum framework does not say that there should or should not be deadlines. The fact that we are forecasting does not mean that we are unable to do deadlines. It just means that we should not be accountable for getting the work done in the time we predict it will be done by because we know that work can take longer than predicted. This is why Essential Scrum proposes fixed date releases with negotiable scope.

>At the end of the sprint, it is important to have a potentially shippable solution. It is ignorant to assume that your sprints content will be done completely. If we would apply math, we would realize that missing the sprint forecast should be the normal state.

I did not say sprint contents should always be done completely. In fact, I agree that it should not always be done completely. Mike Cohn, author of Agile Estimation and Planning, recommends to complete everything that was pulled into the sprint 80% of the time. I don't see what this has to do with deadlines.

>Estimation has the same issue: we are not interested into having a number like "it takes 12h". We are interested into knowing what needs to be done and want the ability to roughly predict the future. As such maybe terms like sizing or task breakdown are better wording.

Isn't sizing some form of estimating? If one user story is a 2 and another user story is a 4, we are estimating that one of the user stories is twice as complex as the other. We don't know that it will actually be twice as complex until we get down to working on it.

Pick up a copy of Mike Cohn's User Stories Applied for a great reference on this topic.

Once you have read that I highly recommend getting a copy of Gojko Adzic's Fifty Quick Ideas to Improve Your Stories (also available on amazon)

You could even roll all of that together and run a story mapping session with your team - this will give them a much broader understanding of what you want the app to do as a whole and you'll get a chance to explain your vision.

EDIT: Hit save early, added story mapping & formatting :)

Being a senior WP dev to me is understanding WP concepts such as hooks, filters, internal API:s etc.

Read this book from start to finish and you can call yourself a senior WP dev:
http://www.amazon.com/Professional-WordPress-Plugin-Development-Williams/dp/0470916222

Lastly, I've met quite a few senior WP devs who are pretty bad to be honest, so you'd be in good company regardless. ;)

Things like list comprehensions are really cool. If you run through all of Learn You a Haskell you'll know more about Haskell than me tbh:

http://learnyouahaskell.com/chapters

There's also my dissertation supervisor's book which is really good for grasping the basics:

http://www.amazon.co.uk/Programming-Haskell-Professor-Graham-Hutton/dp/0521692695/ref=la_B001H6QSUC_1_1?s=books&ie=UTF8&qid=1412108611&sr=1-1

Haskell is so powerful when you utilise it to its full potential, but I never really get the chance to play with it any more. Even so, some of the tricks I learnt from Haskell help me in a lot of the python programming I do.

There's also the fact that Haskell really gets you used to a functional style that can actually make javascript quite nice to work with.

Intuition's actually a pretty good description of it. See, e.g., Lean Software Development (Mary and Tom Poppendieck), p. 61-62:

> Gary Klein studied decision making of emergency responders, military personnel, airline pilots, critical-care nurses, and others, to see how they make life-and-death decisions. He expected to find that these people make rational decisions in life-threatening situations; that is, they survey a range of options and weigh the benefits and risks of each option, then choose the best one from the analysis. When he started the study, he was amazed to discover that fire commanders felt they rarely, if ever, made decisions. Fire commanders were very experienced, or they would not have their jobs. They claimed that they just knew what to do based on their experience; there was no decision making involved. We call this intuitive decision making.
>
> When experienced people use pattern matching and mental simulation to make decisions, they are employing a very powerful tool that has an unquestioned track record of success...
>
> Klein found that firefighter commanders resort to rational decision making only when experience is inadequate. Deliberating about options is a good idea for novices who have to think their way through decisions. However, intuitive decision making is the more mature approach to decisions, and it usually leads to better decisions as well.
>
> Note that intuitive decision making can yield incorrect results if the underlying assumptions are incorrect or the constraints are not well understood.

Yes, I've built several device simulators. Some were quick & easy, just enough for basic system testing. Others were much more involved and were built before the real system even existed. Now I'm at Bright Wolf and specialize in Industrial IoT System Integration. We strongly recommend the use of IoT device simulators so that you can adequately test.

Parasoft has a whole suite of tools that could help with your testing.. In particular, the unit testing framework is helpful (https://www.parasoft.com/product/cpptest/). I'm not sure what language you're using, but if you're trying to unit test embedded c I recommend this book: https://www.amazon.com/Driven-Development-Embedded-Pragmatic-Programmers/dp/193435662X

beyond unit testing, Parasoft also has tools that help you quickly simulate other systems. So, you don't need an entire server/system or Internet connection to test things out. Check out their API testing suite here: https://www.parasoft.com/capability/api-testing/

TPL is great for type theory stuff.

I'm working through Compiling with Continuations right now, and it's pretty good as a practical way to specify semantics that also has a history as useful in compilers. Matt Might's writeup gives a flavor.

> lhs2tex has been using a similar scheme for ages, to support proper lining up of things when Haskell is typeset in proportional font.

This preprocessor was used in the typesetting of the book Programming in Haskell by Graham Hutton. It makes for a quite aesthetic reading experience when not only are the code examples terse and to the point (Haskell!), they are also typeset with wide margins and math-like formatting.

It is generally agreed that programmers don't read enough code. Proposition: code, like all reading materials, should be beautiful to behold.

(Remark: I like the proximity of "should" and "beautiful". As Wittgenstein observed, ethics and aesthetics are one and the same.)

Dependency injection and interfaces are mostly more advanced concepts. You can code most things without doing them properly. It comes into the design of your software and testability. It's not something I'd recommend learning first. When it's time, I highly recommend reading The Art of Unit Testing by Roy Osherove: https://www.amazon.co.uk/Art-Unit-Testing-examples/dp/1617290890/ref=sr_1_1?ie=UTF8&qid=1511991453&sr=8-1&keywords=roy+osherove

Until then, you're better off learning how to actually code in C#, and learning important C# features such as the differences between reference and value types, LINQ, asynchronous programming, threading, and more. You can learn all of this with Venkat's C# for beginners series: https://www.youtube.com/playlist?list=PLAC325451207E3105

To develop a web project, you could then move onto Venkat's MVC tutorial series, however if you're planning to store data, I recommend first watching his Entity Framework and SQL Server series.

Pragmatic Programmer by Dave Thomas and Andrew Hunt.

If you want something you can download for free I thoroughly reccomend The Graphic Programming Black Book by Michael Abrash. Written just after Quake came out it is an exploration of algorithms and optimisation that is just incredibly well written and entertaining.

Yes, it's pretty good. Also checkout Professional WordPress Plugin Development. Even if you don't think you'll be creating plugins, it covers hooks, filters, meta boxes, shortcodes and more. Basically all the advanced stuff you'll need to know anyway.

So this is what I would consider the "Core" reading list for anyone interested in programming games. None of this is really game specific though. These are just the fundamentals you need in order to be an effective Software Engineer.

Learn about...

C++ syntax: Programming: Principles and Practice Using C++ by Bjarne Stroustrup

Software Engineering: Code Complete by Steve McConnell

C++ gems: Effective C++ by Scott Meyer

Software Teams: The Mythical Man-Month by Frederick P. Brooks Jr.

Why we love Joel: Joel on Software by Joel Spolsky

Problem Solving: The Pragmatic Programmer by Andrew Hunt

Common Code Solutions: Head First Design Patterns by Eric Freeman

Pearls!: Programming Pearls by Jon Bentley

I'll do a supplemental on this in a few days that dives into specific topics related to engine development. All of this is generic enough that it will help you regardless of what you do. You'll notice that very little here is actually language specific. Almost all of this is about the art of making software and process of working with a team. These 8 books alone will make you think about making software in a whole new way.

Too many questions :)

I think you should start with unit tests, at some point you will reach the high level interfaces by which your application communicates with the external world (or simply with other components). There, you'll slowly start realising your tests target the behavior of your application rather than assert that your code computes B from a given input A.

It's not always clear what should be called functional or integration testing but with some experience you may get a better feeling for it.

A book that might be quite helpful to start your quest.

In addition you may read this. Though they focus on agile development teams, they still can be relevant.

Totally good idea.

Dive into Pytest.

If you are looking for instructions on how to do this more explicitly a toy example would be:

Step 1: Write a stup for your assignment, say it’s comparing two numbers for equality

def is_equal(x, y):
pass

Step 2: Now in a test file you write some tests which call the function and assert the expected output:

def test_1():
a = is_equal(1, 2)

assert a == False

def test_2():
a = is_equal(5, 5)

assert a == True

Step 3: Invoke pytest from the command line to see if you pass the tests...you don’t...

Step 4: Write code until is_equal passes the tests.

To add to this hard mode approach you want to take I would start a monorepo for all of your school projects. Checkout the GitHub student developer pack and get unlimited private repos. Start a private repo for all of your school projects.

• Make your school projects conform to development best practices
  
• adhere religiously to a style guide
  
• use branching/pull requests to merge code into your monorepo.
  
• write README files for each project directory
  
• use virtual environments (i.e. pipenv)
  
  
  EDIT: Here are some resources for pytest
  
  
• Python Testing with Pytest
  
  
• Pytest docs
  
  
• Pytest Tutorial

I wouldn't say that budgeting is horrible in agile. Agile simplifies budgeting into iteration costs, and then estimates feature sets across iterations. In a very simplified example, if:

1. An iteration ( 10 biz days, 10 devs @ $250/day ea.) costs $25,000
   
2. 30 Features (User stories) defined at an avg of 5 ideal days each. In reality you would not average here but sum individual US estimations.
   
3. That's 150 ideal days.
   
4. Real throughput is 8 ideal days per dev per iteration (overhead of 20%)
   
5. 150/8 =18.75 iterations - call it 20 to add a bit of slack.
   
6. 20 iterations = $500k
   
   Where agile shines regarding scheduling is that the features are developed in the order of product manager / user value - and that value is recognized periodically with interim working product releases. This allows you to realize incoming cash flows earlier than a standard waterfall approach.
   
   Where a scheduler would shine in Agile is in the statistical weighting and ordering of feature priority - not necessarily in the estimation of duration of each Feature / User Story. I highly recommend [Agile Estimating & Planning] (http://www.amazon.com/Agile-Estimating-Planning-Mike-Cohn/dp/0131479415) by Mike Cohn. IMO - the real trick to Agile is the proper ordering of development. If you hash that, you lose the early cash realization, and you can end up with a product that does not meet requirements as you fail to deliver core features before you run out of time/money.

Besides what has been mentioned, these two are also good:

• C Interfaces and Implementations: Techniques for Creating Reusable Software
  : teaches good design practices in C.
  
  
• Writing solid code: focuses on debugging, also filled with interesting anecdotes.

The "Spot the bug" posts here are like that although I think they are c++ (http://blogs.msdn.com/b/rsamona/).

Books like Writing Solid Code (http://www.amazon.com/Writing-Solid-Microsoft-Programming-Series/dp/1556155514) are also helpful if you're going to be writing a lot of C or C++ code. It has some helpful ideas about how to build C code that is debuggable.

Taking a lot of care with regard to what needs to be included where can help. In some cases, you can just give a forward declaration of a class rather than including a header for it if you are just shuffling pointers to it around. In other cases, you can migrate a lot of implementation details using a 'PIMPL' style so only the public facing API is in the headers that get included. Make sure one header doesn't need to include a chain of 100 other headers for dependencies. Be careful with template stuff. Avoid putting templates in headers such that they wind up being recompiled in every source file. You can do explicit template instantiation for the specific types that you need, and you'll only have to compile them once. Divide the project into several small dynamic libraries, so you only have to build one lib at a time instead of the whole project.

I've heard good things about this book, but my build times aren't yet slow enough to give me time to read it. :) http://www.amazon.com/Large-Scale-Software-Design-John-Lakos/dp/0201633620

The Camel Book has a most amazing chapter on Regex - easily worth buying just for that chapter!

I use regex daily. I don't do stuff like decode DVDs with it, but simple patterns can be a godsend when processing string data.

These are the top 3 I'd say:

• Professional ASP.NET MVC 3 Framework (Wrox-August 2011)
  > Jon Galloway, Phil Haack, Brad Wilson, K. Scott Allen
  
  
• Pro ASP.NET MVC 3 Framework (Apress-June 2011) - [Pre-order v4]
  > Steven Sanderson, Adam Freeman
  
  
• ASP.NET MVC 4 In Action (Manning-June 2012)
  > Jeffrey Palermo, Jimmy Bogard, Eric Hexter, Matthew Hinze, Jeremy Skinner
  
  Don't get hung up over V3/V4; there's not a lot new in 4.
  
  Also don't worry about being "up to date", most of your time will be spent trying to figure out the best way to do something; the "how" to do something part is usually very straight-forward, there are just many options.

Read the sidebar for links. Good places to learn Lua:
Lua Manual
Lua Book
Also, Google search returns awesome things like THIS!

Thank you all for your responses! I have compiled a list of books mentioned by at least three different people below. Since some books have abbreviations (SICP) or colloquial names (Dragon Book), not to mention the occasional omission of a starting "a" or "the" this was done by hand and as a result it may contain errors.

edit: This list is now books mentioned by at least three people (was two) and contains posts up to icepack's.

edit: Updated with links to Amazon.com. These are not affiliate - Amazon was picked because they provide the most uniform way to compare books.

edit: Updated up to redline6561

• 14 The C Programming Language
  
• 11 Structure and Interpretation of Computer Programs
  
• 8 Introduction to Algorithms
  
• 7 Compilers: Principles, Techniques and Tools
  
• 6 Programming Erlang
  
• 5 The Mythical Man-Month
  
• 5 The Pragmatic Programmer
  
• 5 Applied Cryptography
  
• 4 Beautiful Code
  
• 4 The Little Schemer
  
• 4 Programming Perl
  
• 3 Types and Programming Languages
  
• 3 Gödel, Escher, Bach
  
• 3 OpenGL Programming Guide
  
• 3 Code Complete
  
• 3 Artificial Intelligence: A Modern Approach
  
• 3 Programming Pearls
  
• 3 ANSI Common Lisp
  
• 3 A Brief History of Time
  
• 3 Agile Web Development with Rails
  
• 3 Concrete Mathematics: A Foundation for Computer Science
  
• 3 Modern Operating Systems
  
• 3 Paradigms of Artificial Intelligence Programming
  
• 3 Operating System Design and Implementation
  
  

Depending on what you're doing and how you're organized, you've got a couple options.

There are, as you've been told in the SO question, a couple commercial solutions. One that wasn't mentioned was ElectricAccelerator, which is also supposed to be a good solution. I believe they have a free/limited trial version these days.

There's also the Team Foundation Server/Build, which is Microsoft's approach to the problem. I've never had cause to use it myself, since it's an all-in on Microsoft tech, which simply isn't tenable for my use-case.

That said, in my experience, a lot of slow builds can be drastically improved simply by organizational changes and good modularity in the code. If your problems are like those I've solved for my current and previous teams, you're likely building your entire stack in a single solution, whether you need to or not. If you can find the pieces that are library-izable and break them out so they're not being built every time, you can get huge gains on the normal day-to-day build times.

I'd highly recommend reading John Lakos's book Large Scale C++ Software Design. It's a little dated, but loaded with still-relevant techniques and information.

I've spent a lot of time fixing builds for myself and others, so feel free to ask questions.

The best that I've found and recommend for learning advanced development with WordPress is called Professional WordPress Plugin Development by Justin Tadlock, Ozh Richard and Brad Williams.

Amazon Link: http://www.amazon.com/Professional-WordPress-Plugin-Development-Williams/dp/0470916222

Generally agree. However,

​

4. LYAH is actually pretty bad, and I wish people stopped directing newcomers to it. There are much better resources around.

5. Afaik, Rust doesn't have higher-kinded polymorphism, which is a huge part of what makes the Haskell type system great. So I wouldn't say they share the same type system.

Haskell is a great starter language for your situation. Once you get into it, you might look at Ermine, as it's specifically developed for financial stuff. The main guy who develops it, Ed Kmett, is also a big Haskell developer. If I recall correctly, he's the head of the committee maintaining the Haskell standard library.

Chris Allen has a nice tutorial on GitHub. Learn You a Haskell is aimed at people who already know imperative programming (Python, Java, C, etc). There's another book aimed at complete newbies, called Programming in Haskell. I haven't looked at that book, but I've heard good things about it.

If you have any questions, you can always ask here, or in the #haskell channel on FreeNode. I'm pharpend in the channel, if you ever want to talk to me.

For designing programming languages, my favorites are

• Types and Programming Languages by Pierce
  
• Practical Foundations for Programming Languages by Harper
  
• The Formal Semantics of Programming Languages by Winskel. For the domain theory and information systems perspective.
  
  If you only get one then go with Pierce. But If you want to get serious about semantics, then Winskel is the way to go.
  
  On the implementation side my favorites are
  
  
• The Dragon Book -- this is the most popular book
  
• Muchnick for the more involved low level optimizations.
  
• Compiling with Continuations by Appel for compiling a functional language.

Well, I'd have to agree! In my undergrad compilers class I wrote an optimizing compiler in SML. We were following Andrew Appel's book, which is published with code and directions for C, Java, and ML, but doing it in ML was particularly nice for all of the reasons outlined here.

I spent a lot of time learning specific architectures and patterns that were in common usage when I first started, but the specific patterns in vogue are constantly changing. I'd recommend reading all 3 of these books at some point earlier in your career, I think a lot of the popular software design practices are based on the foundation of ideas in here and if you read them you will start to naturally make the right choices when it comes to organizing your code.

https://www.amazon.com/Pragmatic-Programmer-journey-mastery-Anniversary/dp/0135957052/ref=pd_sbs_14_t_0/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0135957052&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D

https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=pd_sbs_14_t_2/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0735619670&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_sbs_14_t_1/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0132350882&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D

Assuming you already have a solid enough PHP base, I'd spend time building a theme, and building a plugin. Professional WordPress Plugin Development is an awesome book.

You could also find a theme or plugin you really like and go through the code to see how things are done.

An interesting but brief article. I disagree with the premise that compilation is slow, I find it quick even with hundreds or thousands of source files. When optimizing build speed, look to PCH, forward declarations, better organization, and finally interfaces and pimpl if you're really desperate.

I suggest Large-Scale C++ Software Design by Lakos for more information.

Edit: Of course C++ compilation is a lot slower than some languages, but ~5 minutes to rebuild 1000 files is pretty reasonable.

initially i would avoid learning webforms, have a go at asp.net mvc, this book is how i learnt, its a gentle introduction but you will need to do more to get a deeper understanding, particularly if you need to learn how to interact with a database.

http://www.amazon.com/Pro-ASP-NET-MVC-Adam-Freeman/dp/1430242361/ref=sr_1_1?ie=UTF8&qid=1377855287&sr=8-1&keywords=asp.net+mvc

edit: seems this edition is no good anymore, the edition where they build the sports store application for learning mvc2 was really good but its out dated now.

Steve McConnell's Writing Solid Code is also good. As are the other two in Clean Code's "Frequently Bought Together" section.

This one is pretty good:

https://www.amazon.co.uk/Agile-Estimating-Planning-Robert-Martin/dp/0131479415

Basic:

C++ Primer

Effective C++

Effective STL





Advanced:

More Effective C++

C++ Coding Standards: 101 Rules

C++ Templates The Complete Guide

Large Scale C++ Design

You're kidding right? That's 100% personal preference... It doesn't matter how you place the braces as long as you're consistent.

This: The Microsoft C# Style Guide. It's literally garbage unless you work for Microsoft or a company that also follows this style guide to religiously. They're suggestions by Microsoft on how to write clean code. If you want a real break down on what clean code is read Clean Code or The Pragmatic Programmer and you'll learn what things are actually worth worrying about.

Joel on Software: And on Diverse and Occasionally Related Matters That Will Prove of Interest to Software Developers, Designers, and Managers, and to Those Who, Whether by Good Fortune or Ill Luck, Work with Them in Some Capacity : This book completely changed how I worked and why I worked.

I recommend focusing on the theory and patterns more than any toolkit or framework. Theory stays with you forever while frameworks come and go and are often language specific.

This book got me started. The examples are all in C#, but the theory applies to any object oriented language.

I've read that $30 book far more than any of the $200 textbooks from university, and it improved the quality of my work dramatically.

Little weird that nobody's mentioned this, so...

• Camel...?
  
  Good luck on finding a Perl book discussing video game programming...that's not really its forte.

From software engineering, check out:

• Joel on Software (book, blog): a very approachable introduction to some of the challenges of writing software, deals with things like formal specifications, project estimates, and some unofficial "laws of software engineering".
  
  
• Mythical Man Month (book): probably widely known outside of software, this book is about software project management and is well-known for the anecdote of "adding engineers to a late project only makes it later".
  
  
• The Pragmatic Programmer (book): this is the defacto professional manual that many software developers read within their first few years of professional work. There is good mix of technical guidance and soft skills (working with a team, career development).

Could it be "Writing Solid Code" by Steve Maguire? https://www.amazon.com/Writing-Solid-Code-Microsoft-Programming/dp/1556155514

Anyway, it's still one of my favorite. Highly recommended.

The best introduction to Lua, without a doubt, is Programming in Lua by Roberto Ierusalimschy (the language's creator). I personally have a signed copy of the second edition.

Here is a good book to help learn, if you prefer books.

http://www.amazon.com/Programming-Lua-Third-Roberto-Ierusalimschy/dp/859037985X/ref=sr_1_1?s=books&ie=UTF8&qid=1372257298&sr=1-1&keywords=lua+programming

Agile Testing: A Practical Guide

Continuous Delivery

Clean Code

Obviously, after this you can expand more in the direction of your particular product needs. I've been doing a lot of reading around CI/CD process, and the overall trend towards "DevOps". But you might want to focus on security or performance testing, and that will have its own path.

I'm awaiting this book, it looks like it's going to be good.

https://www.amazon.com/Joel-Software-Occasionally-Developers-Designers/dp/1590593898

One of the only "entertaining" technical reads I've ever had. Highly recommend, especially if you are somewhat new to the industry like I am.

You missed out. Compiler design was my favorite course in college.

Anyway, if you don't mind reading textbooks and digging deep into them, you can teach yourself compilers. The seminal work is the Dragon Book. I'd highly recommend supplementing is with Appel's Modern Compiler Implementation in ML (if you're a wimp, you can get the Java or C versions, but I wouldn't recommend it). SICP can also give you some useful perspectives. If you want to go further, there's Advanced Compiler Design and Implementation by Steven Muchnik.

There are also a couple of web tutorials that give you a really quick, whirlwind overview. Graydon Hoare's One Day Compilers uses Ocaml to write a native-code compiler for a Make-like language in 40 slides. My Write yourself a scheme in 48 hours has you write a Scheme interpreter in Haskell, though it sorta assumes you're already familiar with the basics of parsing/lexing/interpreting.

buy these 2 books:

• The C programming language
  
• Programming in Haskell
  
  and read them in parallel. Both are short well written books with good examples.

if you're looking to get into web development, I would look at the asp.net mvc framework.

I have this book: http://www.amazon.com/Pro-ASP-NET-MVC-Adam-Freeman/dp/1430242361

It is long, but covers the important topics well. Between this and stack overflow, it should be enough to get you started.

There is a 2nd edition version of Art of Unit Testing which came out at the end of 2013 (Original is from 2009) with the examples focusing on C# which may/may not be more useful for people interested:

UK Amazon Link

US Amazon Link

Yes, every header file should include all other headers that it needs otherwise you will have a nightmare keeping track of include order dependencies. In order to speed up compile times you will want to put include guard ifdefs around the #include directive, not just inside.

So:

foo.h:

ifndef _FOO_H

    #define _FOO_H<br />

ifndef _BAR_H

    #include &amp;lt;bar.h&amp;gt;<br />
    #endif<br />

...

endif

bar.h:

ifndef _BAR_H

    #define _BAR_H<br />
    ...<br />
    #endif<br />

IIRC this is as recommended in Lakos' book: http://www.amazon.com/Large-Scale-Software-Design-John-Lakos/dp/0201633620

SECTION | CONTENT

--|:--
Title | Lua Tutorial
Description | Get the Cheat Sheet Here : http://goo.gl/0j15W0 Best Lua Book : http://amzn.to/1SUTogK Support me on Patreon : https://www.patreon.com/derekbanas Data Types 3:43 Math 6:58 Conditionals 10:53 Ternary Operator 15:20 Strings 16:35 Looping 19:11 Repeat Until 20:44 User Input 20:56 For 22:00 For In 22:29 Tables 23:41 Functions 28:26 Return Multiple Values 29:25 Variadic Functions 33:13 Closure 34:27 Coroutines 36:46 File I/O 40:10 Modules 43:32 Metatables 45:30 OOP 51:00 Inheritance 55:04
Length | 0:57:25






****

^(I am a bot, this is an auto-generated reply | )^Info ^| ^Feedback ^| ^(Reply STOP to opt out permanently)

Can't express how good this one is. Overall, any of Mike cohn' books are all great

https://www.amazon.com/dp/0131479415/ref=cm_sw_r_cp_awdb_t1_scbOAbVTE20NV

Edit: user stories applied is another one of his greats:

https://www.amazon.com/dp/0321205685/ref=cm_sw_r_cp_awdb_t1_WdbOAbZP5TPTC

> going through your 800 lines of code to figure out where the bug is

Hmmm, Developer here with 30 years experience.

It sounds to me like you seriously need to learn about debugging. It's something of an issue because most CS courses don't teach how to debug code with anything like the application they should, instead you're sort of left to figure it out on your own.

This is really really old now, and concentrates on pure C, but the techniques it describes are just as relevant today as they ever where and if you see a copy anywhere worth a couple of hours skimming.

https://www.amazon.co.uk/Writing-Solid-Code-Techniques-Programming/dp/1556155514

Get the book Test Driven Development for Embedded C

https://www.amazon.com/Driven-Development-Embedded-Pragmatic-Programmers/dp/193435662X/

It covers all this and more in a very useful level of detail.

Friend, There's a nice book showing how to do TDD in embedded systems from James Granning: https://www.amazon.com/Driven-Development-Embedded-Pragmatic-Programmers/dp/193435662X

Anyways, The magic to do off target testing is to abstract everything that is platform dependent and mock it out on the test build. Some will say if you mock out platform it will be left with nothing to test, but it is not true, anytime you have a data in RAM, it is testable, so you can test most of your embedded code: interrupt handlers, serial buffering, business logic, actuator. By this point you must have figured out that what is mocked out of the application is the peripheral functions and hardware outward.

JoesGym has used dependency injection to abstract hardware, which depending the way it is done it can get big or heavy. I do recommend to start simpler, select ".c" files for a ".h" interface accordingly to the platform in the build scripts, so, for real code, your "uart.c" will actually talk to the peripheral, where in test code "uart.c" will put the data in a special place to be later checked during tests.

In case you'd like to have a look at a simple led blink with TDD project, this is one: https://github.com/flplv/UnitTestingEmbeddedC-Demo1

Programming Perl, by Wall et al., is the classic. Known as the camel book.

Learning Perl, by Schwartz et al., is perhaps better for a true beginner.

Also, is there a major reason you've chosen Perl over something else like Python or Ruby (not to start a war or push you one way, just interested)?

You can replace the implementations of C++'s operator new and delete with your own that do extra processing to ensure all memory is released properly. You would normally only implement this in your Debug builds. When you release an official version of the program to customers you would just remove your modifications (e.g. via an #IFDEF).

Steve Maguire tackles this in his book Writing Solid Code.

Lua and Corona SDK is how I got started with game development, and programming in general. How much experience do you have with programming? If you are an absolute beginner, you may want to check out a tutorial I wrote.

If have a programming background, the book Programming in Lua is a good place to start to learn about the language.

Corona also has a ton of resources on their site called Corona University, so I would definitely check those out.

Thanks everyone for your thoughtful/helpful/motivating replies thus far.

I've now set-up a blog with Hakyll and plan to document my project of doing the Tiger book compiler in Haskell. I know people have previously looked for a compiler book with a project in Haskell, so maybe it will end up being of use to someone!

I liked The Art of Agile Development by James Shore and User Stories Applied by Mike Cohn.

Yeah, it costs a fair amount to get a half decent lab together but once you do!

Instead of electronics, what about getting a book that takes you through a software project and work your way through that. If you wanted to build a compiler for a language then there is plenty of choice, e.g.:
http://www.amazon.com/Modern-Compiler-Implementation-Andrew-Appel/dp/052182060X/ref=sr_1_1?ie=UTF8&qid=1427095404&sr=8-1&keywords=compiler+design+java

http://www.amazon.com/Modern-Compiler-Implementation-Andrew-Appel/dp/0521607655/ref=la_B000AP5X0W_1_5?s=books&ie=UTF8&qid=1427095531&sr=1-5

http://www.amazon.com/Modern-Compiler-Implementation-Andrew-Appel/dp/0521607647/ref=la_B000AP5X0W_1_1?s=books&ie=UTF8&qid=1427095531&sr=1-1


There's other books for other types of project.

Can absolutely recommend the The Art of Unit Testing!

Jeff Patton's Story Mapping, even though it seems more limited from the title, is probably the best introduction on _how_ to do the job.

Agile Testing by Lisa Crispin is one of my favorite testing books.

Joel On Software.

You should also read The Best Software Writing, but those essays are all available online.

Brian Okken’s book might be a good start for you. https://www.amazon.com/Python-Testing-pytest-Effective-Scalable/dp/1680502409

I use CppUTest for my embedded project. It used the book Test Driven Development for Embedded C to get into it. So far I'm rather pleased with it.
There is also Unity.

I don't think there really is a standard framework that everyone uses.

His book is good too on this sort of topic. (I think, anyway.) There are also some expensive videos as part of a workshop.

Embedded.com has a decent reference: http://www.embedded.com/collections/4397931/Object-oriented-C

This book also has some good general OO design info in addition to the test info: http://www.amazon.com/Driven-Development-Embedded-Pragmatic-Programmers/dp/193435662X

I recommend, pytest with this book https://www.amazon.com/dp/1680502409/
and tox https://tox.readthedocs.io/en/latest/ and https://www.youtube.com/watch?v=PrAyvH-tm8E

The book (that online one is for 5.0, the paperback I bought targets 5.2) was phenomenally helpful for me

I'd recommend the basics from searching around, maybe checking out a video on youtube. Figure out how to setup a project using MSTest and one using NUnit (maybe XUnit as well). Do a basic TDD Kata (fizz buzz, etc).

Learn about using fakes/mocks/stubs (NSubstitute is good).

C# Specific book, new version out in November:
The Art of Unit Testing: With Examples in .NET

Get the pre-release here if you want:
The Art of Unit Testing: With Examples in .NET

would recommend this too!

https://www.amazon.com/Driven-Development-Embedded-Pragmatic-Programmers/dp/193435662X

I bought this book, i totally recommend it.

if you can get a copy of Appel's Compiling with Continuations, that will explain the whole thing (probably in way too much detail too).

otherwise there are two libraries, for common lisp, which transform code from "direct style" to continuation passing style:

• cl-cont
  
• arnesi (at least the cps transformer in it)
  
  while reading code that does it isn't quite the same as explaining it, maybe that will help anyway

The Pragmatic Programmer is in my opinion the best book on "etiquette". My first boss in the games industry bought it for me and told me to read and absorb it.

Large Scale Software Design was the book I read about large scale structure, but I think it's kind of out dated if you ask me.

Whenever this is asked I always recommend starting where I did: http://www.amazon.com/Professional-WordPress-Plugin-Development-Williams/dp/0470916222/

Agile Testing is solid on principles. Don't be scared of the agile label, it's a sound foundation for understanding test automation.

I'm not sure what you mean by "from a DevOps perspective" though. To use an extreme example, if the test engineers are writing Selenium tests and running them locally in a QA silo, reading a book about modern test automation isn't going to help you communicate with them.

You'll be showing up in a tuxedo to find everyone else is wearing jeans and an old Mickey Mouse t-shirt. Yes, you're both wearing pants and your torso is covered, but that's about where the common ground ends.

Programming in Haskell was recently released and worth checking out.

The Lua users wiki isn't bad. If you're starting from 0 programming knowledge, buy the book.

Next time you're doing step 3 read this book which might help you cut down on compile times.

https://github.com/ThrowTheSwitch/Unity and https://cpputest.github.io/

These are the frameworks used in this helpful book: https://www.amazon.com/Driven-Development-Embedded-Pragmatic-Programmers/dp/193435662X

EDIT: Remove unfinished sentence.

Books. Beginning Python and Learning Python

The Art of Unit Testing: with examples in C#

https://www.amazon.com/Python-Testing-pytest-Effective-Scalable/dp/1680502409

https://www.amazon.com/Programming-Lua-Roberto-Ierusalimschy/dp/859037985X/ref=sr_1_1?ie=UTF8&qid=1469519691&sr=8-1&keywords=programming+lua

https://www.amazon.com/Art-Unit-Testing-examples/dp/1617290890

LEAN Software Development by Mary and Tom Poppendiek
https://www.amazon.com/Lean-Software-Development-Agile-Toolkit/dp/0321150783

How Google Tests Software -- https://www.amazon.com/Google-Tests-Software-James-Whittaker/dp/0321803027

Agile Testing: A Practical Guide for Testers and Agile Teams -- https://www.amazon.com/Agile-Testing-Practical-Guide-Testers/dp/0321534468/ref=sr_1_1?s=books&ie=UTF8&qid=1493586342&sr=1-1&keywords=agile+testing

A Practitioner's Guide to Software Test Design -- https://www.amazon.com/gp/product/158053791X/ref=oh_aui_detailpage_o07_s00?ie=UTF8&psc=1

here's a book that I used when I was learning and it helped a lot. It's a tad outdated but there's still tons of usefull information.

Programming Perl

ISBN: 978-0-596-00027-1

AKA the Perl Bible.

The book is written by the creator of the Lua Language, edition 3 is the latest:

http://www.amazon.co.uk/Programming-Third-Edition-Roberto-Ierusalimschy/dp/859037985X/ref=sr_1_1?ie=UTF8&qid=1380983432&sr=8-1&keywords=programming+in+lua

I reccomend that you read this and follow his blog too, he's written extensively for this subject amongst others

User Stories Applied: For Agile Software Development (Addison-Wesley Signature) https://www.amazon.co.uk/dp/0321205685/ref=cm_sw_r_cp_apa_i_09mQCb22J357P

What I always suggest is http://www.amazon.com/Professional-WordPress-Plugin-Development-Williams/dp/0470916222

I found writing a theme was more design oriented than any actual development where a plugin by its nature takes more development.

So think of a plugin, big or small, then dive in to trying to make it happen.

I found this book to be incredibly helpful: https://www.amazon.com/Art-Unit-Testing-examples/dp/1617290890/ref=sr_1_1?ie=UTF8&qid=1500721325&sr=8-1

It's not so much about Test Driven Development, but focuses more about how to organize and write unit tests and fakes. Has a lot of discussions pro and con regarding things you may run into. It also compares unit testing frameworks. Keep in mind that the book is over three years old now, so those comparisons may or may not hold up as well anymore. Doesn't detract from the rest of the book though.

Perhaps you can try working part-time in remote crowdsourcing test platforms. You'll get exposed to different types of products and learn quickly how to approach testing strategically.

https://www.amazon.com/Agile-Testing-Practical-Guide-Testers/dp/0321534468 -- I read this while I was still a working student in QA, to understand how QA works in dev teams.

Read up more about: BDD, Gherkin, blackbox testing

I haven't programmed c++ is about 15 years, so take everything I say with a grain of salt. I'll just point you in the direction of people/books that have more knowledge.

If you want to read about unit testing with C/C++, try James Grenning's writings. He, ehm, wrote the book on all this. And with a focus on embedded work, so you can be sure he deals with performance considerations.

There's a concept called 'composed method', which means that a method should do one thing, and one thing only. That also means that it should not have any side effects. And that means that either the method does an operation and returns a value, manipulates state of the class under test or, as you say, operates on some call outside the class.

In the first two cases, it's straightforward to test. In the third, we can use patterns such as dependency injection to inject a fake. Or we can use a mocking framework to isolate the class under test. In C++, this does mean that you need to at least have an interface to be able to create a fake, or make the method virtual to be able to use a mocking framework. Programming against interfaces is not a bad idea, as long as you don't overdo it. In most cases, performance won't be a major issues for this, unless you work on very small devices or have particular performance requirements.

In C#, this all is not really an issue. For JavaScript, have a look at 'Testable Javascript': some nice discussion on testing and event-based designs.

I worked on the Windows operating system and Internet Explorer at various points in my career. With very large projects like those, even normally trivial problems become significant engineering tasks when doing so at those scales. Just compiling the core library of IE (allocators, text handling, dom, etc) could take half an hour, so you really came to appreciate incremental builds.

To get a sense of the scale of such problems, I might recommend the book Large Scale C++ Design. I remember finding the book very dry, but in the author's defense, it's a very dry problem space.

I'd add the following two books to the list to cover TDD and the Software Design phase:

• The Art of Unit Testing by Roy Osherove
  
• Competitive Engineering by Tom Gilb
  
  Disclaimer: I haven't read the latter but am familiar with the contents from courses I've attended with Mr. Gilb. Won't help you how to code but what to code when doing it on a contract.