First, decide how much time you have to spend on the problem and whether it should be tractable or not.
If it's very urgent, and you can hack around it, hack around it. If it's very urgent and important, hack around it now to unblock and then dig into it deeper later (more in a bit). If it's not urgent, you can treat it as a learning experience and dig in deeper if you want to or not. (Basically make sure you don't fall into a rabbit hole while attempting to solve one specific error and make sure you're achieving what you actually need to).
For digging in deeper (because it's just that important, or maybe you just want to learn): make sure you RTFM, figure out where your understanding of the system and the actual system differ – what did you expect to happen, what's happening and then tweak one thing at a time to make sure things are behaving as you would expect them to till you find the reason. There's a lot I could keep writing about this, and I'm fairly certain much better engineers and authors than me have – an example error would have made this easier.
For Android in particular, we're more lucky than iOS engineers because you have access to the underlying code (for the large part) so you can dig into the android source and even debug the part of the framework that runs within your application.
Of course, sometimes it's just frustration and exhaustion in which case you should follow the advice already posted and just take a fresh look at it the next day.
PS. I haven't completed reading this but https://www.amazon.com/dp/B00PDDKQV2/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1 was recommended to me and has been good so far.
This book is based on studies/evidence:
There is some sad truth behind your question: Our industry is based on gut feeling. We do tons of things, even after the evidence tells us that it does not work. Software estimation comes to mind.
With regards to bugs, there are 3 types.
I recommend against story pointing anything except user stories. Ultimately what you want to forecast for planning is "amount of user value" (velocity). Teams naturally start estimating bugs or tasks, but all that overhead is actually already measured just by the user stories. If bugs and tasks take up more time, then the Velocity goes down. It is key here to measure output for the customer NOT amount of work done by the team.
This is something of an oversimplification; in <u>Accelerate</u>, which goes into the DORA metrics more in depth, they go more into their methodology and explain how the metrics correlate with better business outcomes and higher employee satisfaction. (In other words, like any metrics, these can be gamed or can fail to take important measures into account - but there's also solid evidence and reasoning behind them, and they're not just measuring how easy the changes are.)
https://www.amazon.com/dp/B01M9ASFQ3/ is pretty good book.
Devops is kind of more about culture, what tools you happen to choose for your CI/CD pipeline is not all that important, all of them get the job done, although some are more nice to use than others. Choice might also be influenced by what other infra you happen to use.
Nope. The authors of the definitive study included that possibility in the study. https://www.amazon.com/Accelerate-Software-Performing-Technology-Organizations-ebook/dp/B07B9F83WM
Pre-existing teams which adopted a faster cadence of releases saw their number of features released go up and their number of defects (total and per release) go down.
Releasing faster means you release better software, on net.
The book 'Storytelling with Data' has some extremely useful direction on how to convey your point to a lay audience - in other words, how to answer the 'so what?'
You would probably only need to look at the first few chapters which are about identifying and conveying your 'story' to the audience.
Agan's book on debugging:Debugging: The 9 Indispensable Rules for Finding Even the Most Elusive Software and Hardware Problems (I like it because it changed how I think about troubleshooting)
Bentley's Programming Pearls (2nd ed) (a short book, I like it because it is short and full of problem framing perspective - reminds me of Alan Kay's quote, "Perspective is worth 80 IQ points.")
I'd look at Dan Blank's methodologies, these were later developed as LeanStartUp and Lean Canvas, which others have suggested. However, the initial concepts have, in my view, more validity that the later developments - https://www.amazon.co.uk/dp/B0047GMERK/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1
I agree @Taunk, Cole Nussbaumer Knaflic's books are awesome...
Storytelling with Data, A Data Visualization Guide for Business Professionals - Cole Nussbaumer Knaflic (Wiley 2015)
https://www.amazon.com/Storytelling-Data-Visualization-Business-Professionals-ebook/dp/B016DHQSM2
Oh shit. Do I have some books for you.
Start here
You'll be writing a smart contract by the time you're halfway through.
It walks you through from zero to there in 100 pgs.
I already have the book but a searchable PDF version will make the final less ridiculous. He makes his tests retarded.
This is it if you're up for it. Management Information Systems for the Information Age 9th Edition, Kindle Edition
For the lazy:
Introducing Ethereum and Solidity: Foundations of Cryptocurrency and Blockchain Programming for Beginners by Chris Dannen http://www.amazon.com/dp/B06XQFYL2M/ref=cm_sw_r_cp_udp_api_zY8.yb1RR3MYB
For Video courses, try: https://www.udemy.com/courses/search/?q=solidity&src=ukw
Good intro book: https://www.amazon.com/gp/product/B06XQFYL2M/ref=oh_aui_search_detailpage?ie=UTF8&psc=1
Then watch out for the Andreas Antonopoulos' Ethereum book coming out later this year.
Neither are specified to me. I do have the first two chapters available so we could compare a few pages if you found one!