Software development, like many other disciplines, is based on two distinct pillars: A paradigm: which is a common set of techniques, methods, principles, assumptions, best practices and other artifacts that define a body of knowledge about how to craft high quality code. A production process: which is a set of techniques and procedures that allow the production of code under the constrains of delivery on time, to spec and within budget. This course is a workshop oriented presentation and exploration of software craftsmanship within the object oriented paradigm. The course is built around a hands on development project which students are expected complete and have functional by the end of the course. Each module is designed to introduce a set of software craftsmanship principles which are then applied by the students in the further refinement of their project. Students work in groups following a simplified Agile development methodology in order to keep the focus of the material on what needs to be done from a software craftsmanship perspective and how that integrates with different processes types like waterfall, interactive and Agile without getting bogged down in process details. The emphasis of the course is on: Architectural design: of both code base and from application perspective with emphasis on these topics as work organization methods. Code design: organizing code components, modules and structures from a functional perspective. The basic principles of elegant and sound design (for example, use of interface and implementation). Code structure: planning and organization of code elements like classes, methods, packages and modules. Principles of good code structure, re-factoring and code smells. Code formatting: making code easy to read, easy to follow and modify or update. Effectiveness: working with frameworks, deigning code for reuse, developing best practices, the right amount of documentation. Best practices: using testing and test driven development, self-applied metrics, eliminating common sources of error, code organization and maintaining a healthy code base. Course Structure The course is structured in a series of phases or iterations that follows what would normally be the sequence of development in a real life project. This is done for two reasons. The first is to create a learning environment that emulates a work environment as closely as possible. The second is to present material to the students at the point that it is most relevant to what they are doing and thus has a higher mastery and retention rate.For each phase the objectives of the phase are identified and students start to implement the phase objectives. This is followed by a class discussion on what the issues were that were discovered, the a lecture section presents the relevant information addressing the issues the students raised as well as any they didn't. This is immediately followed by the hands on "re-work" session where the material is applied by the students in a mentored fashion. Phase 1: Students are organized into teams, and have their first session with the client to scope their project. An iteration plan is developed and a basic proposal on code standards and the architecture of the code base us explored. Phase 2: Students develop a functional architecture based on requirements. The architecture is used as an opportunity to explore code structure and design in accordance with good OO programming best design practices.. Phase 3: Students get ready to write code by setting up their test driven development environment, develop their test cases and set up a code plan. Phase 4: After the basic code is written and proven to be functional the students redesign their implementation using re-factoring to meet the non-functional requirements of the system. Phase 5: After the code is tested, groups swap projects under the premise that each group will be maintaining and supporting another group's code. A final code review and analysis is performed.
This is a course for programmers. Students should be experienced in an object oriented language such as Java or C#. The course is four days in length. Students who cannot code in Java, C++, C# or a similar language competently will not be able to follow the course content.
4 Days/Lecture & Lab
This version of the course is for advanced students only. If differs in two primary ways from the introductory course. The first is that the programming project is significantly more difficult and challenging and requires substantially more effort and creativity from the students.The second difference is the manner of presentation of the material. In this class the students will inductively explore what needs to be done as they work on the project which will then be confirmed in the lecture. For the introductory class the sequence is lecture-work, in the advanced class the sequence is work-lecture-rework
- Craftsmanship Defined
- Code Design
- Code Structure
- Code Formatting and Documentation
- Testing and Debugging
- Refactoring Improving Structure
- The Code Base
- Using Frameworks and Tools
- The Programming Process
- Putting it all together