When I started learning backend development, I thought building software was mainly about writing code.
But as I started the IBM Back-End Development Professional Certificate, I realized something important: writing code is only one part of building software.
So, I decided to start documenting my learning journey, beginning with a fundamental question: What is Software Engineering?
What Is Software Engineering? Understanding the Foundations of Building Software
My Backend Development Learning Journey | IBM Back-End Development Professional Certificate
I'm currently starting my journey through the IBM Back-End Development Professional Certificate. Before diving deeper into backend technologies like Python, Django, databases, and APIs, I started with an important question:
What is Software Engineering, and why do we need it?
At first, I thought software development was mainly about writing code to build applications. But I started understanding that building reliable software involves much more than programming.
Let's explore what I learned.
1. What Is Software Engineering?
Software engineering is the application of engineering principles, systematic methods, and tools to design, develop, test, deploy, and maintain software.
In simpler terms, software engineering is about building software in an organized and reliable way to solve real-world problems and meet user and business requirements.
A real-world analogy
Imagine you're building a custom car.
You wouldn't just start assembling random parts. You would:
- Understand what the customer needs.
- Design the car.
- Select the appropriate materials.
- Build the different components.
- Test the car for safety and performance.
- Maintain and improve it over time.
Software engineering follows a similar approach.
Instead of physical components, we work with code, databases, APIs, architectures, and software tools.
The goal isn't simply to make software work. It's to make it reliable, maintainable, efficient, and useful.
2. The History: What Was the Software Crisis?
To understand why software engineering became important, we need to look at the history of software development.
During the early days of computing, programming practices were relatively informal compared with today's standards.
As computers became more powerful, software systems became larger and more complex.
Developers started facing serious challenges, including:
- Projects exceeding their budgets.
- Development taking longer than expected.
- Software containing numerous bugs.
- Systems becoming difficult to maintain.
- Applications failing to meet user requirements.
These challenges became known as the Software Crisis.
The term gained prominence during the 1968 NATO Software Engineering Conference, where experts discussed the growing difficulties of developing large software systems.
How did the industry respond?
The industry began adopting more systematic engineering practices, including:
- Standardized development processes.
- Structured programming.
- Software design principles.
- Testing and quality assurance.
- Documentation.
- Computer-Aided Software Engineering (CASE) tools.
CASE tools help automate or support software engineering activities such as modeling, design, documentation, and testing.
These approaches helped the industry manage software complexity and improve development practices.
However, software engineering didn't magically eliminate every software development problem. Managing complexity, cost, time, and quality remains an important challenge today.
3. Software Engineer vs. Software Developer
One interesting thing I learned is that software engineering and software development are related, but they aren't exactly the same concepts.
A useful way to understand the distinction:
Software Engineering is a discipline that applies engineering principles to the entire software lifecycle.
Software Development is the practical process of creating and improving software.
Software engineers often consider the bigger picture, including:
- System architecture.
- Scalability.
- Reliability.
- Security.
- Maintainability.
- Technical requirements.
Software developers focus on implementing software functionality, such as:
- Writing code.
- Building application features.
- Integrating components.
- Fixing bugs.
- Testing functionality.
However, these responsibilities overlap significantly. In many companies, the titles Software Engineer and Software Developer are used interchangeably.
A backend developer, for example, might write API endpoints while also making architectural decisions and considering database performance.
The important thing is to understand that software engineering is more than just writing code.
4. Connecting Software Engineering to Backend Development
Let's imagine we're building an e-commerce application using Python and Django.
The application needs:
- User registration and authentication.
- Product management.
- Shopping cart functionality.
- Order management.
- Database integration.
- API endpoints.
- Security and permissions.
We could immediately start writing Django code.
But an engineering mindset encourages us to ask questions first:
- What exactly should the application do?
- Who will use the application?
- How should the database be designed?
- How should different components communicate?
- How will we protect users' information?
- How will we test and maintain the application?
These questions help us move beyond simply writing code and start thinking about building complete software systems.
5. Key Takeaways
Here are the most important things I learned from this lesson:
- Software engineering is more than programming.
- Building reliable software requires planning, design, development, testing, and maintenance.
- The Software Crisis highlighted the difficulties of managing large software projects.
- Engineering principles and structured development practices help manage software complexity.
- Software engineers and software developers have overlapping responsibilities.
- Understanding the entire software system is important, especially when developing backend applications.
Final Thoughts
This lesson changed how I think about software development.
Previously, I mostly associated building applications with writing code. Now, I'm starting to understand that writing code is only one part of a much bigger process.
As I continue learning backend development, I want to focus not only on how to implement something, but also on why we implement it in a particular way.
That's the mindset I want to develop throughout this journey.
Learning source: IBM – Introduction to Software Engineering (Coursera)
Learning series: IBM Back-End Development Professional Certificate
This article represents my personal understanding and notes from the course. I'm documenting my progress as I learn, explore, and build my skills in backend development.
Top comments (0)