Course Overview
As Martin Fowler wrote in his famous blog post, Flaccid Scrum, many Agile Software Development efforts fail, because they do not adopt Agile Engineering practices, which are not covered by the Scrum methodology. Agile Engineering practices allow teams to accommodate frequent changes, while still delivering code that is low in bugs, and deployable at the end of each sprint.
This course goes beyond an academic discussion of Object-Oriented Design and goes into a deep discussion of its effects on practical software engineering concerns such as maintainability, testability and reuse. The course then proceeds to discuss critical Java best practices which affect performance and correctness. This is followed by a discussion on modern software engineering approaches of Test-Driven Development and Refactoring, which improve the quality and maintainability of the codebase.
Students are provided with numerous hands-on exercises, the most challenging of which is the final team machine problem, which includes changes to requirements mid-way!
Learning Outcomes
- The course culminates in a Code Review, where students present their solutions to the final machine problem to the class, for review and critique by the instructor as well as by the entire class on the basis of Object-Oriented Design principles and Java Best Practices. This activity is demonstrably effective in instilling proper practices and approaches for students.
Course Outline
Agile Engineering Overview
- Economic effect of bad code
- Technical debt vs technical investment
Review of Object-Oriented Programming
- Basic Pragmatic considerations
- Importance of encapsulation
- Advantages & disadvantages of inheritance & polymorphism
- Refused Bequest,
- Fragile Base Class Problem
- Danger of complexity
- Composition & delegation
- Favor composition over inheritance
- Liskov Substitution Principle
- Design by Contract
- Principle of Least Surprise
Object-Oriented Design
- Code Smells
- Information Expert
- Law of Demeter
- Single Responsibility Principle
- Separation of Concerns
- Don’t Repeat Yourself
- Protected Variations
- Common Reuse Principle
- Common Closure Principle
- Acyclic Dependencies Principle
- Stable Dependencies Principle
Continuous Integration
- A continuous integration tool will be used in their final machine problem
Unit Testing and Test Driven Development
- JUnit introduction
- Tests as documentation
- Tests drive design
- FAQs & best practices
- several mob coding exercises on TDD & Refactoring
Refactoring
- Boy scout principle
- Two-hats metaphor
Java Best Practices
- String Pool,
- String Immutability
- String vs StringBuffer
- Performance considerations
- BigDecimal vs floating point primitives
- Collections best practices
- Exception Translation
- validating parameters and fields
- Defensive Copies
- Enums vs Constants
- Favor Immutability
- Overriding toString()
- Overriding equals() & hashCode()
- Avoid Passing Null
- Use Optional
- Exceptions best practices
- Closing resources
- Synchronization best practices
Machine Problem
- Group work that tests the team’s ability to write maintainable code
- Change request will be introduced towards the end of the machine problem to challenge the maintainability of the code
Code Review
- Review of machine problem
Skill Level
Intermediate
Suitable For
Anyone who has basic knowledge and experience with Java, wanting to explore Agile Engineering practices
Prerequisites
- JAVA-101 — Java Fundamentals (or equivalent experience/training)
Duration
5
day
s
Related Topics
Enquire Now
Skill Level
Intermediate
Suitable For
Anyone who has basic knowledge and experience with Java, wanting to explore Agile Engineering practices
Duration
5
day
s
Related Topics
Course Overview
As Martin Fowler wrote in his famous blog post, Flaccid Scrum, many Agile Software Development efforts fail, because they do not adopt Agile Engineering practices, which are not covered by the Scrum methodology. Agile Engineering practices allow teams to accommodate frequent changes, while still delivering code that is low in bugs, and deployable at the end of each sprint.
This course goes beyond an academic discussion of Object-Oriented Design and goes into a deep discussion of its effects on practical software engineering concerns such as maintainability, testability and reuse. The course then proceeds to discuss critical Java best practices which affect performance and correctness. This is followed by a discussion on modern software engineering approaches of Test-Driven Development and Refactoring, which improve the quality and maintainability of the codebase.
Students are provided with numerous hands-on exercises, the most challenging of which is the final team machine problem, which includes changes to requirements mid-way!
Learning Outcomes
- The course culminates in a Code Review, where students present their solutions to the final machine problem to the class, for review and critique by the instructor as well as by the entire class on the basis of Object-Oriented Design principles and Java Best Practices. This activity is demonstrably effective in instilling proper practices and approaches for students.
Course Outline
Agile Engineering Overview
- Economic effect of bad code
- Technical debt vs technical investment
Review of Object-Oriented Programming
- Basic Pragmatic considerations
- Importance of encapsulation
- Advantages & disadvantages of inheritance & polymorphism
- Refused Bequest,
- Fragile Base Class Problem
- Danger of complexity
- Composition & delegation
- Favor composition over inheritance
- Liskov Substitution Principle
- Design by Contract
- Principle of Least Surprise
Object-Oriented Design
- Code Smells
- Information Expert
- Law of Demeter
- Single Responsibility Principle
- Separation of Concerns
- Don’t Repeat Yourself
- Protected Variations
- Common Reuse Principle
- Common Closure Principle
- Acyclic Dependencies Principle
- Stable Dependencies Principle
Continuous Integration
- A continuous integration tool will be used in their final machine problem
Unit Testing and Test Driven Development
- JUnit introduction
- Tests as documentation
- Tests drive design
- FAQs & best practices
- several mob coding exercises on TDD & Refactoring
Refactoring
- Boy scout principle
- Two-hats metaphor
Java Best Practices
- String Pool,
- String Immutability
- String vs StringBuffer
- Performance considerations
- BigDecimal vs floating point primitives
- Collections best practices
- Exception Translation
- validating parameters and fields
- Defensive Copies
- Enums vs Constants
- Favor Immutability
- Overriding toString()
- Overriding equals() & hashCode()
- Avoid Passing Null
- Use Optional
- Exceptions best practices
- Closing resources
- Synchronization best practices
Machine Problem
- Group work that tests the team’s ability to write maintainable code
- Change request will be introduced towards the end of the machine problem to challenge the maintainability of the code
Code Review
- Review of machine problem