Monday, June 25, 2012

20 Subjects Every Software Engineer Should Know

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.

4Big-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 enginnering 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: 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.


  1. Great compilation, Just like to add one more thing "Better communication", this is what makes difference between a good developer and great developer and something either comes naturally or takes lot of effort to improve.

    10 OOOPS and SOLID design principle for java developers

  2. I disagree with Big O Notation and UML. In over 20+ years of software development, I have never seen Big O Notation used. Development teams that try to use pure UML typically find it extremely cumbersome and time-consuming, so they end up using some short-cut version of it.

    1. Big O notation is one of the fundamentals of data structures & algorithms. If you didn't use it how did you calculate algorithm complexities?

      In addition, this post doesn't enforce using pure UML or its most detailed form. It only recommends to learn UML and use it as required on requirement analysis and design.

  3. some more pragmatic things are missing, IMO:
    - know your application domain: most of them are as complex as SWE - seeing it as 'there are user requirements' is not enough. it might require to become half an engineer...
    - today every responsible SW-guy should/must have an idea about copyright/licenses/intellectual property.
    - have an idea about the short/long-term costs of those fancy ideas and hypes the gurus whisper in your ear

  4. Nice article. I would remove Big-O Notation and add XML and Web Services

  5. Inspired by this article I listed the books that in my opinion will help enyone that wants to read for these subjects.

  6. this 20 subjects as you described in this post among them i would know about 12 subject in routine life do it also.

  7. Very Nice website. I just finished mine and i was looking for some ideas and your website gave me some. Feel free to know more about online software engineering