Here are the most important subjects for software engineering, with brief explanations:
1.Object oriented analysis & design: For better maintainability, reusability and faster development, the most well accepted approach, shortly OOAD and its SOLID principals are very important for software engineering.
2.Software quality factors: Software engineering depends on some very important quality factors. Understanding and applying them is 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.
7.Design patterns: Design patterns
are standard and most effective solutions for specific problems. If you
don't 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.
10.Network basics: Network
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, antipatterns
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): DI or IoC
(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.
