After using IBM BOB IDE almost daily for the past 6 months, I noticed something surprising:

My team usually exhausted thier bobcoins, but I’ve never exhausted my Bob coins.

This isn’t because I use it less. In fact, I use it for coding, debugging, planning, and architecture and almost everything.

The real reason ? I learned how to use it efficiently.

This article breaks down the practical strategies that helped me maximize value without burning through tokens.

⚠️ The Hidden Cost of “Context”

One of BOB’s most powerful capabilities is its ability to understand your codebase by scanning context.

But here’s the catch:

The more files it reads → the more tokens it consumes → the more coins you spend.

Most developers unknowingly allow:

• Full repository scans
• Test files
• Build artifacts
• Dependency folders

This leads to:

• Slower responses
• Noisy outputs
• Rapid coin consumption

🔑 Real hidden techniques = “.bobignore”

BOB provides a simple yet powerful mechanism to control this:

👉 .bobignore

📘 Official guide: https://bob.ibm.com/docs/ide/configuration/bobignore

Just like .gitignore, this file tells BOB: “Ignore these files while building context.”

💡 What I exclude in most projects:

node_modules/
coverage/
dist/
build/
public/
*.test.*
*.spec.*
*.env.*

✅ Immediate impact:

• Reduced context size
• Faster processing
• More relevant responses
• Significant coin savings

⚡ Real-World Impact

Before using .bobignore:

• BOB scanned everything
• Included unnecessary files
• Consumed more tokens

After implementing it:

• Only core business logic is analyzed
• Responses became sharper
• Coin usage dropped dramatically

🧠 Smart Ways to Save BOB Coins

Here are additional strategies that made a big difference:

1. 🎯 Use the Right “Mode” for the Task

Heavy modes like planning or deep analysis consume more tokens.

👉 Use them only when necessary.

2. ✂️ Ask Focused Questions

❌ “Explain my entire codebase”

✅ “Explain the flow of this service method”

Smaller scope = better answers + lower cost

3. 🧩 Break Problems into Steps

Instead of one large prompt:

• Ask step-by-step
• Build understanding incrementally

This improves both: Accuracy, Efficiency

4. 🔁 Leverage Conversation Context

BOB already remembers previous interactions.

👉 Avoid repeating:

• Code snippets
• Context explanations

This reduces redundant token usage.

5. 🔍 Be Intentional with File Access

Every file BOB reads contributes to token consumption.

👉 Only allow access to what’s truly needed.

🚀 Advanced Tip: Create Custom Modes

If you frequently perform similar tasks, create reusable prompt templates:

• Debugging Mode
• Refactoring Mode
• Documentation Mode
• Github/Jira Mode
• Code Review Mode

This avoids:

• Rewriting long prompts
• Wasting tokens on repeated instructions

🧭 Final Thoughts

Most developers think: “I need more coins.”

But the reality is: You need better context control and prompt discipline.

When used smartly, even the default credits are more than enough for daily development.

🔗 Useful Links

• 📘 .bobignore Guide: https://bob.ibm.com/docs/ide/configuration/bobignore
• ⬇️ Download BOB IDE: https://bob.ibm.com/download?bob=ide

💬 What About You?

Have you tried optimizing AI tool usage like this? Or are you still letting it scan everything?

Let’s discuss 👇

#IBMBOB #AIForDevelopers #DeveloperProductivity #GenAI #SoftwareEngineering #DevTools #AIIDE #EngineeringLeadership

Testing is essential if you want to keep a codebase maintainable, improve release planning, and maintain a sane workflow.

If you don’t have a testing strategy in place before implementing features or building capabilities, your team will face immense stress during every release cycle. More importantly, the end-user experience can be a disaster.

As a development lead, I always advocate for a TDD (Test-Driven Development) approach. Having seen projects both with and without testing strategies, the difference is clear: without one, teams struggle to deliver features quickly and confidently.

In reality, quality is hard to maintain unless leadership understands the long-term impact of technical debt. We plan development work years, months, and sprints in advance, yet many people still overlook the testing strategy.

Trust me: without a testing and release strategy, your project isn’t a professional product — it’s just a POC or a never-ending hackathon.

Different kind of testing

There are different types of testing you can implement, and the right mix varies from case to case. The three most common are Unit, Integration, and Functional testing.

1. Unit Testing

Unit testing is about testing your code in its smallest parts. It is deterministic, meaning that for a specific input, it should always return the same result.

• Scope: It focuses on logic. However, not everything can (or should) be unit tested — for example, private methods are typically internal implementation details, and certain framework lifecycle events can be difficult to isolate.
• External Dependencies: If your method relies on third-party dependencies like RESTful APIs or databases, you must use mocks or stubs. This ensures you are testing your logic, not the reliability of the internet or an external server.

2. Integration Testing

While unit tests look at the parts, Integration testing verifies that different modules, services, or units function correctly as a group. It specifically focuses on interactions and data flow.

• The “Bridge”: Integration testing sits between unit and functional testing, ensuring the “bridges” between individual parts of your system are reliable and that data is passed correctly between them.

3. Functional Testing

Functional testing is a broad category that describes what the software does rather than how it’s built. It verifies that each function operates according to pre-defined requirements or specifications.

• User-Centric: This can range from checking a single button’s behavior to validating a complete user journey. It asks the question: “Does this feature actually do what the business requirements asked for?”

Pyramid of testing

AAA patterns

To write consistent and readable unit tests, the developer community widely uses the AAA (Arrange, Act, Assert) pattern. This framework provides a clear structure for every test you write.

• Arrange: This is the setup phase. Here, you define the prerequisites, initialise your objects, and prepare the input data required for the test.
• Act: This is the execution phase. You call the specific function or method that you want to test.
• Assert: This is the verification phase. You check the outcome against your expectations.

Assertions are the most critical part of the process; they define the quality and reliability of your tests. A test without a strong assertion is just code running without a purpose.

What makes a test “good”?

• Name or title of tests should be self describing.
• Fast and quick: They should run quickly.
• Independent : tests shouldn’t depend on each other.
• Repeatable: Running it everytime should return the same result.
• write more and significant asserts

Tools

The developer community has built an incredible ecosystem of tools to support testing. Whether you need an assertion library, a mocking framework, or a test runner with beautiful reporting, there is a solution available for every major language and framework.

For JavaScript like Jest, Mocha, chai, Jasmine, React-testing-libary etc.

For Java JUnit, TestNG, Mockito etc.

Conclusion

When we plan for development, we must plan for testing. Choosing “fast development” while skipping a testing strategy is a short-term approach that creates an illusion of progress. In reality, it builds a fragile foundation that will eventually slow you down or break under pressure.

To build a robust product and take your engineering to the next level, a testing strategy is not a “nice-to-have” — it is a must. It is the difference between a project that survives the first release and a product that thrives for years.

Stop participating in a “long-term hackathon.” Start building with confidence.

ANTLR stands for “ANother Tool for Language Recognition”

There are multiple language recognition tools available they are also parser generator.

So either we can write our parser with lexer with visitors and listeners functions for transformation and then create a AST (abstract syntax tree)

OR

We can use ANTLR like PARSER generation tools by just providing on grammar files, rest things will be taken care by tools.

To describe it again — In ANTLR, we just need to write a grammar files(.g4), rest parser generation programs (like components, different kind of files, classes, functions) will be generated by ANTLR.

ANTLR is a JAVA tool, we just need to include ANTLR JAR in our code. Once we have grammar files (.g4) then run a simple commands java commands to generate parser code.

Let’s talk about terminologies —

Parser generators — Here ANTLR is parser generator which creates parser program for us by just providing grammar files.

Grammar files (.g4) — there two files ANTLR expects us to provide as input, one is for lexers or tokeniser for lexical analysis, and second one is for Parser to analyse syntactical rules, specifying how tokens combine to form valid sentences or expressions. Both files are called grammar files and their extension is “.g4”

Lexer rules in an ANTLR grammar must start with an uppercase letter (e.g., INT : ‘0’..’9'+ ;). And Lexer rules try to match the longest possible sequence of characters from the input. If multiple rules match the same length, the rule defined first in the grammar takes precedence.

Parser rules must start with a lowercase letter (e.g., declaration : INT ID EQUALS NUMBER SEMI ;). And Parser rules are composed of other parser rules and/or lexer tokens.

Parsing tree — this is also called abstract syntax tree (ast). this created when parser analyse the source code using Visitors and Listeners.

Visitors — is controlled traversal in AST to process the parse tree.

Listeners — similar to visitors but kind of interceptors based on event driven. Suitable for logging, transformation.

Now Let’s talk about flow — how ANTLR generates parser, and how parser generates AST. We can understand using following diagrams.

1. ANTLR build PARSER — which is available for lexical analysis and syntactical analysis of input source code
2. After this parser build an abstract syntax tree
3. while traversal on AST, visitors and listeners are used to process and transform
4. which helps to interpret source input.

This blog is just an introduction to start with ANTLR or any parser generation tool. For detailed understanding of ANTLR, you can checkout following references.

References —

ANTLR

• GitHub - antlr/antlr4: ANTLR (ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files.
• The Definitive ANTLR 4 Reference

Here are some highlights, I prepared for myself, but I believe these can be helpful for others. Lets start —

On writing Notes —” My ego was bigger than ranbir kapoor’s dating list.” Sometimes we don’t listen or respect people because of our ego. That is completely true. That point, we start geting destroyed ourselves. Whatever we achieve in our life, that could be just a small success. we can’t not greater than destiny.

Why Notes are important — Because they helps us in revision. Effective revision without good class notes is not possible. May be this advice is for college students, but as a life student, this practice of keeping your notes upto date, will be helpful to everyone.

Biggest reason for people to get fail in life, competition, office… is Overconfidence.

Human craves appreciation all the time. Everyone craves for appreciations.

Never ever cross the line, in overconfidence — on small success celebrations.

Life never fails to bless you with little sparks (inspirations, motivations).

When you work hard, you put yourself at the pinnacle and the rest of the world seems naive. <— mistake we do mostly.

Your thoughts and opinions feels superior and you fail to acknowledge a simple thing, you fail to take in suggestions, and feedbacks. Think like whatever you are thinking, could be wrong.

Sometimes it becomes some kind of show off for us — showing people I study a lot, I work a lot, I do a lot…. Solving/reading a ton of books always saying NO to fun. And this cost us effectiveness or may be health too.

Being Donkey — is very common problem in India. Doing what we like to do only. Not getting focus on our shortcomings, weaknesses. For example — solving problems which we are already good, and ignoring problems which scare us.

Half knowledge is devastating.

Small insignificant things creates the biggest differences (Kaizen). They can transform a average person to highly visible person. For example working on each problem(DSA, or PCM problems for IITs) until you became proficient in them.

Another Example — pushups before going for bath — can make your hand’s muscles better than 90% of world.

Another example — making notes, listening with full focus, revising notes, analysis mock papers etc, etc.

Another example — working one at time, one by one, on your weaknesses like verbal and non-verbal communications, your behaviours with others, handle problems smoothly, Be silent observer, health habits going on walk, start running, reading, listening, writing, emotional intelligence, solving sudoku, or playing chess, grow your network etc.

Perspective changes on each and every activity — trust me, all this make you package. People like package when you will be compared with others, better package’s one will be selected. For example — when a girl look into you as future husband. Another example — when an employer look your profile.

Like a masterpiece, great things take time to come in life.

Dheere dheere re mana,

dheere sab kuch hoye.

Mali seeche sau ghada,

ritu aaye fal hoye.

With persistence and patience, even the most challenging things becomes effortless and success comes easy. This is called Consistency.

Consistency is harder when no one is clapping for you — Luis Garcia.

One single addiction can cost us thousand dollars and our physical and mental health.

Any vicious cycle, you will be crushed by competition next day. now what is vicious cycle — “A vicious cycle is a situation where one problem leads to another, creating a chain of events that makes the original issue worse.”

For example — you start watching a movie, your backlog of todo will grow like anything. you delve yourself in movie or web series or insta reels, you won’t be able to come back.

Distractions — could be toxic relationship, watching porn , social media like instagram, youtube, smoking/drinking etc. These distractions will act as a source of leakage, we can call them “Open Window”. In the beginning , they weigh nothing but after some days, they will leak your energy and time, you will be left with less mind space, less energy and time. we don’t like when somebody tax on our earning, so these distractions will be like tax on everything.

So good thing on these distraction is they could be in our control. We need to work on MINDSET, TARGET, PRIORITY, and PLANNING.

If you raise a question, people bless you, because everyone has question, but few of them have courage.

Dost ache toh banao hi par jiske dost ho uske ache dost bano bhi — Bassi.

• for Some time, be caveman.
• Work on your distractions like mobile notifications, shopping.
• Sometime give time to yourself — rest karo, maje karo, chill karo.

Replacing old habits, takes time and efforts.

Our parents have the biggest goldmine — a wealth of experience.

Never revise for your mock / practice tests/interview.

Tests/ Exams/ Interviews —

• Read / Listen the instructions carefully.
• attempt the question paper in 3 rounds. 1st → go for easy questions, 2nd → solve questions higher in toughness and 3rd → all remaining questions (toughest, simple but calculative, short but tricky).

Karma will eventually catch up with you.

One of toxic habit — Indians have is — eating heavy meals.

Another one problem is this kind of thought— “every activities other than study — is a waste of time.”

Atleast 30 min, we should give everyday to one of activities like Table tenis or any sports, creative activities like arts, singing and playing music etc.

Different focus techniques — Pomodoro, Eat the frog, The Eisenhower Matrix etc.

If you want to be like a person, then shoot a compliments to them.

Self-doubt, stress, anxiety and pressure — Sit straight, drink water, talk to your friends, or parents.

To Start any new habit — generally it takes 21 days to 42 days. Don’t start with complex or harder way in beginning. Slowly increase the complexity and make it harder day by day. But make sure you are enjoying it.

Most People gives up on 2nd day — so if you reach to 2nd day you are ahead of many people. Trick is simple — Start with simple task — once it becomes easy then go for next difficultly level.

Instead of time table, make task list. Use “The Eisenhower Matrix” technique.

Overall this is very basic book, but if you read this book at any point of life, it will remind you what mistakes you did or doing right now.

I always believe simple books are more impactful than lengthy tough language books.

Thanks to Author — Shobhit nirwan.

• Keys in list rendering, do not generate keys on the fly, e.g. with key={Math.random()}, or use Array’s default index. Instead use something dynamic like timestamp or uuid.
• Put things in strictMode —as this is development only behavior. No impact on production. If component are impure, then this helps to identify the wrong things.
• Pure functions / components — same input same output. ReactJs asks developers to make functions and components as pure.
• But Remember everything can’t be pure, do not stress to make things pure perfectly. Only component, initialiser, and updater functions need to be pure.
• Event handlers don’t need to be pure, so React will never call your event handlers twice. Effects can’t be pure.
• Immutability — React there are three kinds of inputs that you can read while rendering: props, state, and context. You should always treat these inputs as read-only.
• We can improve performance by skipping rendering components whose inputs have not changed.
• start reading about usecases of — useMemo and useCallback
• Passing JSX as children — When a component visually wraps other components, let it accept JSX as children. This way, when the wrapper component updates its own state, React knows that its children don’t need to re-render.
• Keep your rendering logic pure.
• Do not use flushSync() to force update on DOM unnecessarily. There could be change in design.
• Avoid unnecessary Effects that update state. Most performance problems in React apps are caused by chains of updates originating from Effects that cause your components to render over and over.
• Try to remove unnecessary dependencies from your Effects. For example, instead of memoization, it’s often simpler to move some object or a function inside an Effect or outside the component.
• Prefer functional components over class components
• Single Responsibility Principle (S of SOLID)
• When multiple components need to share state, lift the state up to the nearest common ancestor.
• For global state management, consider using the Context API to avoid prop drilling. For more complex state management, libraries like Redux or MobX can be beneficial.
• For smaller applications, we don’t need to redux or any state management library. Sometimes useState or useReducer or useContext is good enough to handle states of application. Don’t follow trends, think twice before using Redux in your project, every solution comes with a cost of managing its complexity.
• Code Splitting: Implement code splitting using dynamic imports and React’s Suspense to load components only when needed, improving initial load time.

I know, list is not completed, there will be many other observations which also need to take care while working on react, please add in comments if you have any other observations.

Happy Learning.

Debugging is important and critical skill to develop any application. If developer does not know about debugging, then productivity will be low, very low. Even he won’t be able to deliver anything properly.

Debugging in VSCode

How to start — let’s say you have started your react application on localhost:3000 port, as shown in below screenshot.

Now Go to “Run and Debug” and click on “create a launch.json” label

Then new popup will be opened at top center of VSCode like this —

Select “Web App (Chrome)” option

one file will be opened with name of “launch.json”

In this file you just need to update your url port — 3000 (as my react app is running on 3000, update according to your configuration of react app).

After this just click on “Start Debugging” icon, as shown in below screenshot.

After this, new chrome will be opened and you just need to put a debugger break point.

Like this setting — you can debug your react application in VSCode itself.

Debugging in Chrome

1. Open developer tool in chrome,
2. find your code file in source tab.
3. Then add break point in function or file.

See below screenshot — that is pretty simple then VSCode debugging.

Sometimes people. find it difficult to debugging in VSCode because of minor configuration.

Debugging in VSCode also possible for Java, Python, NodeJS etc. Even we can debug both Frontend and backend code together by attaching. May be I will create a new blog for same.

Advance Debugging

Advance Debugging If you want to debug more deeper way, then I would suggest Chrome extension React Developer Tool. This extension allows to inspect React components, edit props and state, and identify performance problems.

This is advance when developer become proficient in reactJS, but good to read, have a exposure of advance react debugging.

Hope this would help people, Happy learning!

References —

• React Developer Tools - React
• Debug code with Visual Studio Code
• Debug JavaScript | Chrome DevTools | Chrome for Developers
• React Developer Tools - Chrome Web Store
• A Beginner's Guide to JavaScript Debugging in Chrome - CoderPad

Ollama — large language models (LLMs), it is open source LLMs.

Ollama can run LLMs on local machine, good usage in those project who does not want to compromise on privacy and want to have good control on experiments. Means — Offline usage or experiment.

1. To begin, let’s download from official website.
2. unzipped the downloaded file and Install locally.
3. use below command to check whether OLLAMA is installed or not, it is running or not

open http://localhost:11434

Run below command to start using particular model

ollama run llama3.2

We can pull any model from models library using below command.

ollama pull <Model_name>

or you can directly run particular model using run command, Model will be pulled implicitly.

ollama run <Model_name>

Time to demo -

I asked temparature of bengaluru, but it could not tell, as it is not using internet, it is using its own past learning which comes with particular model (Here it is llama3.2).

• If Model is continue to print output for long time, you can use ctrl+C to stop answering for previous question
• Use /bye to exit the REPL(terminal).
• CLI Reference: Run ollama helpin the terminal.

What we can do locally -

• Can run various open-source LLMs
• Can Create your own web interface using REST-API.
• Can build AI-powered tools
• offline Development
• Keep sensitive data and AI processing within their local environment.
• Experience AI Without Relying on the Cloud
• No Usage Limits
• lowers the barrier to entry for interacting with and understanding large language models

In the end -

AI is going to change the world, it is revolutionary.

It is a necessity to learn it, to understand its capabilities.

Job trends are getting changed, budgets are getting cut, leaders are pressurised — in the end, it will be propagated to bottom of hierarchy.

Be ready for change yourself, because CHANGE is the only thing which is constant.

you can checkout more information about Ollama LLM

• Website: https://ollama.com/
• Find more models: https://ollama.com/library
• GitHub: https://github.com/ollama/ollama
• Docs: https://github.com/ollama/ollama/tree/main/docs
• API: https://github.com/ollama/ollama/blob/main/docs/api.md
• Python SDK: https://github.com/ollama/ollama-python
• JS SDK: https://github.com/ollama/ollama-js

“Time management is crucial for work-life balance, everyone must understand this and use it wisely” — Anonymous.

We all want to be more productive, right? But it’s hard to focus for long periods. I used to find myself working for hours without realizing how much time had passed. This led to feeling stiff and tired, which isn’t good for my body or mind.

I learned that taking short breaks can actually help you work better. It’s like giving your brain a rest so it can come back refreshed. There’s a technique called the Pomodoro Technique where you work for 25 minutes straight, then take a 5-minute break. You can repeat this a few times.

To help me stick to this, I looked for a tool to block distractions like websites and notifications. I found a Chrome extension called FocusGuard — Block Websites and Focus Mode that’s really helpful. It lets me set timers for work sessions and blocks websites that might tempt me to waste time.

I’ve noticed a big difference in my focus and energy since using this method. It’s like hitting the reset button on my brain every 25 minutes.

Have you tried anything similar to improve your productivity? I’d love to hear about it!

Thanks for reading.

const InitialCounter = ({ counter }) => {
  console.log("initialCounter Component - ", counter);
  return (
    <h4>
      initialCounter : {counter >= 0 && counter <= 5 && "Red"}
      {counter > 5 && counter <= 10 && "Green"}
      {counter > 10 && <>Blue</>}
    </h4>
  );
};
export default function App() {
  const [counter, setCounter] = useState(0);
  return (
    <div>
      <h1>value of Counter {counter}</h1>
      <InitialCounter counter={counter} />
      <button onClick={() => setCounter(counter + 1)}>Increment by 1</button>
      <button onClick={() => setCounter(counter - 1)}>Decrement by 1</button>
    </div>
  );
}

In this example, initialCounter component has a prop “counter” which is getting changed from parent component on click of buttons, which re-renders child component though child component output does not change on every click of button.

Here is output of above code snippet.

Here we can optimise this component by preventing re-rendering by using memo function and useMemo hook provided by react. Here is the solution-

const OptimizedCounter = memo(({ colorValue }) => {
  console.log("optimizedCounter Component ", colorValue);
  return <h4>OptimizedCounter : {colorValue}</h4>;
});

export default function App() {
  const [counter, setCounter] = useState(0);

  const colorValue = useMemo(() => {
    if (counter >= 0 && counter <= 5) return "Red";
    else if (counter > 5 && counter <= 10) return "Green";
    return "Blue";
  }, [counter]);

  return (
    <div>
      <h1>value of Counter {counter}</h1>
      <OptimizedCounter colorValue={colorValue} />
      <button onClick={() => setCounter(counter + 1)}>Increment by 1</button>
      <button onClick={() => setCounter(counter - 1)}>Decrement by 1</button>
    </div>
  );
}

In above solution, memo function prevents re-rendering when its props does not change, it memoized the component. And useMemo hook helps to run its function on change of counter value in parent component and memoized the return value which does not change every time based on dependency array items.

Here is the output of browser console.

So Both useMemo to memoized the colorValue and memo function to memoized child component, here to solve this problem.

This is kind of unique problem with simple example. But when component is quite large, then it is quite hard to identify such optimisation opportunity . That’s why it is recommended to make your component as small as possible like unit functionality or smallest UI.

There could be more solution for this problem, suggestions are welcome.

Happy Learning.

Accessibility, usability, and inclusion are closely related aspects in creating a web that works for everyone. Their goals, approaches, and guidelines overlap significantly. It is most effective to address them together when designing and developing websites and applications.

Accessibility verification of any web application, requires following three different methods —

1. Test with automated tools
2. Test with manual inspections
3. Test with a screen readers

Test with Automated Tools is a method to automate accessibility testing. There are multiple third party libraries available which support to automate web accessibility. These libraries provide browser extensions and integration testing modules(e.g. Jest, karma, Node, Cypress). This is the most efficient way to find accessibility issues in your application.

Some third party libraries are — Accessibility checker, cypress-axe etc. Initially we have used Accessibility checker but later we found cypress-axe which was almost same but there was better community support for cypress-axe.

Test with manual inspection is divided into multiple different steps. A visual checks then by pointer and keyboard checks. Then validate the resizing of content. Manual testing is completed by confirming the accessibility of interactions. These are the steps which can’t be automated as of now. In future we might have automated tools of some checks.

Test with screen reader to confirm that the experience parallels the results from manual testing and is equivalent to the intended design.

A screen reader is assistive technology software used by people who are blind or visually impaired. It provides text and semantic information about interactive elements to enable the user to understand and interact with the operating system, applications, and Web content. The screen reader communicates the information to the user using text-to-speech. some of popular screen readers —

Free:

• NVDA
• Windows Narrator
• VoiceOver (macOS/iOS)
• Orca (Linux)

Paid-for:

• JAWS
• Dolphin
• Window-Eyes
• System Access

we used JAWS on windows based OS and Voiceover on Mac based OS.

Overall Accessibility is quite important as part of software development and it should get started while designing of application. A lot of tools, trainings and documentations are available in community, which can help to develop skills and mindset of accessibility, usability and inclusion.