20 Subjects
Every Software Engineer Should Know.
Here are the most important subjects for software
engineers with brief explanation.
1)
Object oriented analysis & design.
.For
better maintainability and faster devalopement, the most well accepted
approach. Shortly OOAD and its solid principles are very important for software
engineers.
2)
Software quality factors:
:
software engineers depends upon some quality factors. But understanding and
applying them is very crucial.
3)
Data structures & algorithms:
Basic data
structures like array, list, stack, tree, map, set etc. and
useful algorithms are
vital for software development. Their logical structure should be known.
4)
Big-O notation: Big-O notation indicates
the performance of an algorithm/code section. Understanding it is very
important for comparing performances.
5)
UML notation:
UML is
the universal and complete language for software design & analysis. If
there is lack of UML in a development process, it feels there is no engineering.
6)
Software processes and metrics:
Software engineering is not a random process.
It requires a high level of systematic and some numbers to monitor those
techniques. So, processes and metrics are
essential.
7)
Design patterns:
solutions for specific
problems. If you don't Design patterns are standard and most effective want to reinvent the wheel, you should learn them.
8)
Operating systems basics:
Learning OS basics is very
important because all applications runs on it. By learning it, we can have
better vision, viewpoints and performance for our applications,
9)
Computer organization basics: All
applications including OS requires a hardware for physical interaction. So,
learning computer
organization basics is vital again for better vision,
viewpoints and performance.
is related with computer
organization, OS and the whole information transfer process. In any case we
will face it while software development. So, it is important to learn network
basics
.
11)
Requirement analysis:
Requirement
analysis is the starting point and one of the most important
parts of software engineering. Performing it correctly and practically needs experience
but it is very essential.
12)
Software testing:
Testing is another
important part of software engineering. Unit testing, its best
practices and techniques like black box, white box,
mocking, TDD,
integration testing etc. are subjects which must be known.
13)
.Dependency management:
Library (JAR,
DLL etc.) management, and widely known tools (Maven, Ant, Ivy etc.) are
essential for large projects. Otherwise, ant patterns like Jar Hell are
inevitable.
14)
Continuous integration:
Continuous
integration brings easiness and automaticity for testing large
modules, components and also performs auto-versioning. Its aim and tools
(like Hudson etc.) should
be known.
15)
ORM (Object relational mapping):
ORM and
its widely known implementation Hibernate framework is an important technique
for mapping objects into database tables. It reduces code length and
maintenance time.
16)
DI (Dependency Injection):
(Inversion
of Control) and its widely known implementation Spring framework makes life
easy for object creation and lifetime management on big enterprise applications.
17)
Version controlling systems:
VCS tools (SVN,
TFS, CVS etc.) are very important by saving so much time for collaborative
works and versioning. Their logical viewpoint and standard cammands should be
known.
18)
Internationalization (i18n):
i18n by
extracting strings into external files is the best way of supporting multiple
languages in our applications. Its practices on different IDEs and technologies
must be known.
19)
Architectural patterns:
Understanding architectural
design patterns (like MVC, MVP, MVVM etc.) is essential for
producing a maintainable, clean, extendable and testable source code.
20)
Writing clean code:
Working code is
not enough, it must be readable and maintainable also. So, code formatting and readable code development
techniques are needed to be known and applied.
