What do you do if your web development code isn't working?

I use breakpoints in the dev tools or console logs or sometimes a combination of both to check and see how the data is flowing.

Console log error guides in a significant way to locate the exact location where code breaks and having issues. In most cases there will be JavaScript errors or any js code in conflicts with each other.

First I will review the code and try to understand the flow, if I don't find any error in the code then I will use console logs and debugging tool to find the exact place where I need to fix the error.

When your web development code isn't working, start by checking for error messages in your browser's developer console or server logs. Review your code for syntax errors, typos, or logical mistakes. Use debugging tools to step through your code and check variable values. Ensure dependencies are correctly included and up to date. Verify configuration settings such as database connections. Test your code in different environments and browsers. Finally, don't hesitate to ask for help from forums or communities dedicated to web development.

When you encounter an error in your code, examining the error logs can be incredibly helpful. These logs contain valuable information that can assist in debugging the issue. By analyzing the error logs, you can identify the root cause of the issue and determine how to fix it. Taking the time to properly debug your code can save you time, effort, and frustration in the long run.

You can read the console errors logs, by reading the logs you can find the source of the error. If the error is from the backend server you may get 500 internal server error or 404 or 403 etc. in that case you have to check the server logs and fix the issue if it is from the server side.

When a specific problem in a web development happens, the first step is to eliminate the cases not related with the possible problem. To focus directly in where the problem really is. For example, one search is not working anymore. This can be problems from: front end, connection, backend, database, UX, etc. Begin with the simplest, like using dev tools to check the connection and the answer of the server to check if the server is answering as expected. In this way step by step you can go deeper to your problem in a quick way, eliminating the already checked possible problems.

I recommend to use console logs or alerts if the code is complicated to find the problem. Either, can use break points in the development tools or sometimes can use combination of both break points and console log for find the root cause of the problem.

Simply understanding the point of error, i.e. the line at which it occurs is very helpful if you are using JS. From there you can review the function or the logic implementation. Else, there may be some errors that might not be part of the code, these errors are usually 500 errors, or CONN_REFUSED errors etc.

I always review my code first. Add console.log statements inside every if statement to check if that condition is working or not. If working on the php server side, then I simply use var_dump() to check if the values are submitted in the correct format or not.

Code reviews are invaluable for identifying overlooked issues and gaining fresh perspectives in development. By sharing code with another developer, errors can be highlighted, improvements suggested, and new debugging techniques introduced. When deeply immersed in coding, it's easy to overlook details, making a colleague's insights invaluable for catching errors like misplaced semicolons or incorrect function calls. Conducting regular code reviews fosters collaboration, improves code quality, and ultimately enhances the overall development process.

Once upon a time, I was working in PHP integrating Oracle 11g database in my PHP application. I was not aware of implementing stored procedures earlier. For saving blob data I have taken 3 days to explore and cracked it. At that time I didn't find the solution in stack overflow or googling I just got some ideas to fix it only. The thing here is to Try to explore the new stuff as much as u can then you will be successful

If you find it difficult to identify the problem on your own, you can always ask a coworker for help to review it together. They might provide some ideas that you haven't considered yet.

Review Your Code: Go through your code line by line to identify any syntax errors, typos, or logical mistakes. Sometimes, a simple oversight can cause a problem.

If your web development code isn't working, simplify by isolating the problematic section. Check for syntax errors, review console logs for clues, and test step-by-step. Verify dependencies and ensure proper environment setup. If recent changes caused issues, review them. Utilize debugging tools and online resources for assistance. Seek help if needed, and iterate until the problem is resolved.

When your code doesn't work, a good strategy is to understand what isn't actually working and limit the scope of analysis. In other words, divide and conquer. If the feature is too large and/or complex to determine the cause of the error, perhaps this is a good indication that it should be broken down into smaller parts. This way, the cognitive effort when analyzing smaller parts is also lower, making it easier to validate the code snippet in question. As each section is validated individually, the complexity of the overall functionality analysis is also reduced.

Sometimes the code is complicated, making it difficult to find the problem. In such cases, I recommend to start introducing some random alerts and console logs to see which part is causing the issue. The issue would be surely there, where the alerts or the console logs are not working!!!

In general when we write code we should always try to apply the Single Responsibility Principle that means breaking the entire logic into multiple functions where each function does a single task. With this the code will become more readable, easy to understand, easy to debug and find the issue in case code isn't working as expected.

Try to simplify the code with the help of software development techniques and good practices such as those in the book Clean Code.

Most of the time, the errors you face are due to the open-source library. It's always a good idea to search for the error on the internet and 98% of the time you will find a similar issue reported or asked by someone else.

Usually, someone has had a similar problem that you can search for on the internet. If it's a very specific issue, nowadays ChatGPT can also help, but remember to consider privacy concerns.

Stackoverflow & ChatGPT & Github issues are great resources for solving problems. However, trying to identify the problem autonomously and solve it creates a proficient developer. Relying on online resources from the beginning of the development career without understanding the reasons of the failing code affects your learning process.

As online resources the proper official documentation is a blessing other then that tech communities websites and also AI (ChatGPT, Gemini) are also use full to understand something

🚩 Red flag: Refactoring isn't as simple as it seems. Don't "go for it" blindly. It should be the last step in your bug-fix process since it involves a lot of effort (and extra costs). So be cautious, and structure your ideas first before changing any line of code, otherwise, you might introduce new issues and bugs to your system. My advice: Beauty lies in simplicity. Keep your codebase as simple as possible. Put effort into making it readable, adopt naming conventions, and implement good patterns in your project. Happy coding!

Consider refactoring your code to improve readability, maintainability, and performance. Refactoring involves restructuring existing code without changing its external behavior, making it easier to identify and fix bugs.

Best practices for refactoring code that developers should keep in mind: Only refactor when you have a safety net: Make sure you have a set of green tests (automated tests that pass) covering the relevant functionality before you start refactoring. This ensures you don't accidentally break something while cleaning up the code. Plan for refactoring: Allocate dedicated time for refactoring tasks. This helps you focus on improving the code without the pressure of new features or bug fixes. Refactor in small steps: Don't try to overhaul the entire codebase in one go. Instead, make small, incremental changes that are easier to manage.

Utilize automated refactoring tools available in IDEs like Visual Studio Code or JetBrains IntelliJ IDEA to perform common refactorings such as extracting methods, renaming variables, or reorganizing code structure. Practice Test-Driven Development (TDD) or Behavior-Driven Development (BDD) methodologies, where you write tests before implementing code, to ensure that your refactorings don't introduce regressions or unintended behavior.

Cry 😭 Cry 😭 Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭Cry 😭

Experiment and Test: Make small changes to your code and test them to see how they affect the behavior of your application. This iterative approach can help you identify the root cause of the problem more effectively.

Take a Break, drink more coffee, take a shower (make sure you spend at least 30mins in the bathroom), Restart your code editor or your Pc (just to be sure)

Sometimes another eye and brain can give advice or a point of view you didn't think about. So try pair programming with your colleague or friend to find the issue.

copy your code into AI tools like Gemini ask question about the issue that you are facing in the functionality for debugging.