Ram Lal Yadav
Associate Professor
SCSS, JNU, Jaipur

Computer science is not just about making apps or writing programs. It’s more about solving problems that people face. Today, we need to look at problems in a bigger way. Two very important ideas help us do that:

• Thinking in systems, and
• Designing with empathy

Let’s look at these two ideas in a very simple and clear way.

What Is Systems Thinking?

A system is made up of different parts that work together. For example, a school website is a system. It has student data, login pages, servers, databases, and users (like students and teachers). If one part fails, the whole system may not work well.

Thinking in systems means we don’t just fix one small issue—we look at how all parts are connected. If one part is slow or broken, it might affect other parts too.

Example:

Suppose your college exam portal is crashing often. Restarting the server might help for a short time. But a deeper look (systems thinking) may show that:

• Too many users are logging in at the same time
• The code is not well-optimized
• The database is overloaded

By understanding the whole system, we can fix the root cause, not just the symptom.

Why Is This Important?

Thinking in systems helps us:

• Find real causes of problems
• Avoid fixing the wrong things
• Plan better for the future
• Keep systems strong and reliable

This is very useful when making software for schools, banks, hospitals, and other real-life use cases.

What Is Designing with Empathy?

Now let’s talk about empathy. Empathy means trying to understand how others feel. When we create software or websites, we should think like the person who will use it.

Designing with empathy means asking questions like:

• Is this easy to use?
• Will it confuse the user?
• Can people with less tech knowledge still use it?

Example:

If you build a mobile app for online classes, think about:

• Can older teachers use it without help?
• Is it clear where to click for students?
• Does it work on all types of phones?

Empathy helps us build tools that are not only functional, but also friendly and helpful.

Putting Both Together

When we use both systems thinking and empathy, we build better solutions.

Let’s take a college exam system as an example. It includes:

• Making time tables
• Seating arrangements
• Attendance
• Mark sheets
• Teacher duty list
• Debarred student list

A systems thinker will look at:

• How data is shared between modules
• Where errors can happen
• What happens if one part fails

An empathy-driven designer will ask:

• Can teachers upload marks easily?
• Will students see clear messages?
• Is the attendance system simple for staff?

Combining both helps us make a tool that works well and is easy to use.

Real-World Areas Where This Approach Works Well

• Education Technology
  Building learning apps those are simple for students and teachers.
• Health Software
  Designing hospital systems that work well and are safe for patients.
• Banking Apps
  Making sure people can use digital banking without confusion.
• E-commerce Sites
  Helping buyers and sellers use the website smoothly.
• Government Services
  Ensuring even rural users or older people can access services online.

How Students Can Learn This

Students studying computer science should:

• Think about how all software parts connect
• Always ask: “How will a real person use this?”
• Try to fix the real problems, not just surface errors
• Keep things simple and user-friendly

By doing this, students can build strong and useful software that makes life easier for others.

Final Thoughts

Computer science is not just about technology. It’s about helping people through technology. If we think in systems, we can build software that works well. If we design with empathy, we can make people’s lives easier.

By using both together, we create not just systems, but smart solutions that truly make a difference.