Best products from r/practicemodding

We found 6 comment on r/practicemodding discussing the most recommended products. We ran sentiment analysis on each of these comments to determine how redditors feel about different products. We found 5 products and ranked them based on the amount of positive reactions they received. Here are the top 20.

Top comments mentioning products on r/practicemodding:

u/LieutenantKumar · 0 pointsr/practicemodding

...continued...

> Test plans - When you apply for QA roles, you'll almost certainly be asked "how would you test ____?". The correct answer is to be methodical. Don't just spew out a stream of test cases as you brainstorm them. Understand the different scopes (unit, functional, integration, maybe end-to-end) and what the goals of each is, and how they differ. Understand that there are different areas of testing like boundary, happy path, special cases (null, " ", 0, -1), exceptions, localization, security, deployment/rollback, code coverage, user-acceptance, a/b, black box vs white box, load/performance/stress/scalability, resiliency, etc. Test various attributes at the intersection of a compenent and a capability (borrowed from the book How Google Tests Software), and I believe you can see a video that goes into this called The 10 Minute Test Plan. Understand how tests fit into your branching strategy - when to run bvts vs integration vs regression tests.

> Test methodologies - Understand the tools that make you an efficient tester. These include data driven tests, oracles, all-pairs / equivalency class, mocking & injection, profiling, debugging, logging, model-based, emulators, harnesses (like JUnit), fuzzing, dependency injection, etc.

> Test frameworks - Knowing all the tests you need to write is good, but then you have to write them. Don't do all of them from scratch. Think of it as a system that needs to be architected so that test cases are simple to write, and new functionality is easy to implement tests for. I can't recommend any books for this because it's something I learned from my peers.

> Test tools - Selenium / WebDriver for web ui, Fiddler for web services (or sites), JUnit/TestNG, JMeter (I have to admit, I don't know this one), integration tools like Jenkins, Github/Stash, git/svn.

> System design - As you're entry-level, this may not be a huge focus in an interview, but know how to sensibly design a system. Know which classes should be used and how they interact with each other. Keep in mind that the system may evolve in the future.

> Whiteboarding - Practice solving problems on a whiteboard. The process is more than just writing the solution, though. This is the process I follow (based loosely on the book Programming Interviews Exposed):

  • Clarify the problem - resolve any ambiguities, determine behaviors for special cases (throw an exception vs return null?). Look for gotchas (like if you're doing some string manipulation with overlaps)
  • Give a couple test cases to demonstrate your understanding of the problem, to make you think of other special cases, and because they want someone who's test-focused if you go into QA. Give a happy path scenario and a couple negative or special cases
  • Propose a solution - do this verbally, and give its runtime complexity (and less importantly, its memory usage). If the runtime complexity is bad (polynomial, exponential), then say so and think of a better solution (there will almost certainly be one)
  • Implement the solution - verbalize your thought process while doing so. If you don't know something, say so. The interviewer will likely help you out without penalty. Listen very carefully for clues, because the interviewer will be giving them. Really understand everything the interviewer says, and understand his motivation for saying it. If you see potential bugs, say so ("I want to be careful that I don't go out-of-bounds in the last iteration of this loop").
  • Debug the solution - walk through it as if you're a debugger, using the happy path test case that you made earlier. Oftentimes, the interviewer will give you a test case with the problem. Use it - he probably selected it for a reason (the numbers are in an interesting order that will find the most bugs, for example).
  • Test the solution - Add to the handful of tests you gave earlier. Think about the different types of tests, and if they apply.

    Resources:-

    > Learning to test:

  • How Google Tests Software
  • Guice, and another
  • Google Test Automation Conference
  • Netflix's Simian Army
  • Google Testing Blog
  • Hermetic testing
  • The Art of Software Testing (I've only skimmed it)

    > Learning to interview:

  • Programming Interviews Exposed
  • Programming Pearls

    > Learning to program:

  • Design Patterns (I'm embarrassed that I don't have more recommendations for this...)

    > Miscellaneous

  • Meetup
  • Inventing on Principle

    > What sort of skills should I really hone? I realize I gave you a ton of stuff in this post, so here's a shorter list:

  1. Read How Google Tests Software
  2. Understand dependency injection
  3. Understand unit, functional (use hermetic environments), and integration testing
  4. Understand mocking (Mockito's a good one for java)

    > Examples of projects that make you look valuable

  • Refactoring product code to be Guice-friendly
  • Tool to profile method calls simply by adding annotations
  • Tool to automate bug filing/updating/closing - assign to the right person, re-activate when they repro, give good steps, close when they're fixed and don't repro
  • Tool to automatically quarantine flaky tests that aren't caused by product bugs
  • Aggregation of distributed logs into central, indexed location (I didn't write the solution, just did the work to integrate an existing one (Logstash/Kibana))
  • Automatically display the picture of the team member who checks in code with the highest coverage (I didn't do this, just something cool I read about)
  • Tool that logs messages with contextual information, so for example you can see all messages associated with user 123
  • Tool that captures inter-server traffic, associated with the user-request
  • Tool that provides metadata about test cases in your web proxy