1. .NET MSc in Distributed Systems David Grey Rob Miles University of Hull, UK

2. Overview  Teaching Undergraduate Computer Science Traditional approaches Traditional approaches Challenges and opportunities Challenges and opportunities  Making a.NET-based degree Background, aims and content Background, aims and content The role of.NET, SSCLI (Rotor) and AA programmes The role of.NET, SSCLI (Rotor) and AA programmes  Example laboratory exercise

3. Computing @ Hull  ~ 580 undergraduate students,  ~ 60 taught/~ 40 research postgraduates  Undergraduate degrees Computer Science, Software Engineering, Business Information Engineering, Internet Computing, Games Development Computer Science, Software Engineering, Business Information Engineering, Internet Computing, Games Development  Taught postgraduate degrees Graphics and Visualization, Games Programming, Internet Computing Graphics and Visualization, Games Programming, Internet Computing

4. Undergraduate Computer Science  Our approach is fairly conventional: Year One Year One Introduce broad range of underlying theoryIntroduce broad range of underlying theory Year Two Year Two Extend Year One theory with more advanced topics and greater depth of contentExtend Year One theory with more advanced topics and greater depth of content Year Three Year Three Individual specialism and further advanced topicsIndividual specialism and further advanced topics Large individual software projectLarge individual software project  Our graduates have a broad range of skills which will serve them well in the future, but these are not fully developed

5. The Challenge  Three years is not enough time!  To achieve this breadth of coverage we tend to lose the depth  We do not have time to expose the students to large systems and appropriate development techniques  We have little opportunity to give students all the testing/debugging skills needed by industry

6. The Result  In September 2003 we begin teaching the.NET MSc in Distributed Systems Development  This degree: is a world first, developed in conjunction with Microsoft UK and the Rotor product team is a world first, developed in conjunction with Microsoft UK and the Rotor product team is a response to the challenges we face at the undergraduate level and the skills that employers require is a response to the challenges we face at the undergraduate level and the skills that employers require uses Microsoft.NET to explore distributed systems concepts uses Microsoft.NET to explore distributed systems concepts uses Rotor to explore the design and implementation of modern languages and distributed computing environments uses Rotor to explore the design and implementation of modern languages and distributed computing environments offers in-depth development of testing and debugging skills using the Rotor source as an example of a large, commercial-quality software system offers in-depth development of testing and debugging skills using the Rotor source as an example of a large, commercial-quality software system

7. .NET Degree – Aims & Content  Aims Give advanced coverage of modern distributed computing techniques Give advanced coverage of modern distributed computing techniques Develop skills in working with large codebases Develop skills in working with large codebases To develop “active practitioners” To develop “active practitioners” Provide hands-on practical experience underpinned by advanced theoretical concepts Provide hands-on practical experience underpinned by advanced theoretical concepts Designed in conjunction with Microsoft, but taught as a genuine academic course Designed in conjunction with Microsoft, but taught as a genuine academic course

8. Degree Structure  Three stages:  Certificate Stage Skills to underpin the original work Skills to underpin the original work  Diploma Stage Advanced computing topics Advanced computing topics  Masters Stage Practical deployment of techniques Practical deployment of techniques

9. Certificate Stage

10. Diploma Stage

11. Masters Stage  Large, individual project based on real- world problem using Rotor or other commercial-grade software  Examples FORTH implementation FORTH implementation Custom Garbage Collection Custom Garbage Collection Custom Remoting / object mobility Custom Remoting / object mobility Code profiling Code profiling

12. The Role of.NET and Rotor .NET provides an overreaching example of distributed systems concepts/techniques  Rotor provides “down to the metal” implementation details “down to the metal” implementation details excellent environment for enhancing testing/ debugging skills excellent environment for enhancing testing/ debugging skills  Not simply a.NET degree The techniques which are learnt can be applied in any area The techniques which are learnt can be applied in any area

13. Debugging Skills  Teaching what to do when it all goes wrong is difficult  Students will have to debug their own programs but do not have to spend much time debugging other peoples  We are setting the “worst case” scenario: There is a problem with the underlying implementation There is a problem with the underlying implementation Their program is fine, but it still doesn’t work! Their program is fine, but it still doesn’t work!

14. A Rotor-based Laboratory Exercise  A live demo  A debugging exercise from the Extensible Systems module designed to: get the students thinking about all aspects of the compilation/execution cycle (challenges some pre-conceptions?) get the students thinking about all aspects of the compilation/execution cycle (challenges some pre-conceptions?) provide opportunities to develop debugging and testing skills provide opportunities to develop debugging and testing skills familiarise the student with the Rotor code and the techniques used to implement it familiarise the student with the Rotor code and the techniques used to implement it

15. Debugging Exercise – Step 1  Student are asked to write a C# program to bubble sort the following numbers static float[] data = {45.0, 6.5, 435.2, 22.0, 6.3, 100.1, 0.02, 99.9, 45.0, 17.4, 56.4};  Being kind people, we even suggest an algorithm Simple bubble sort Simple bubble sort

16. Debugging Exercise – Step 2  Compile and run the program using the Rotor C# compiler and the Rotor CLI  At this point the students have to decide if their code is at fault Inexperienced programmers are prone to problems with array bounds Inexperienced programmers are prone to problems with array bounds First they must convince themselves that their program is correct First they must convince themselves that their program is correct They will not expect the language implementation to cause problems They will not expect the language implementation to cause problems

17. Debugging Exercise – Step 3  Can we verify the correctness of the code in any way? Use the.NET C# compiler and CLR Use the.NET C# compiler and CLR  Hypothesis if it works in.NET our code must be valid if it works in.NET our code must be valid  Outcome The program works correctly in this environment The program works correctly in this environment

18. Debugging Exercise – Step 4 Conclusion:  Something about the Rotor environment or C# compiler causes the problem  Hypotheses Something is wrong with the implementation of for loops? Something is wrong with the implementation of for loops? Something is wrong with the < operator Something is wrong with the < operator  Write some simple programs to test these hypotheses

19. Debugging Exercise – Step 5  Something is definitely not right…  Hypothesis The C# compiler generates Common Intermediate Language code. Perhaps the code generation is incorrect. The C# compiler generates Common Intermediate Language code. Perhaps the code generation is incorrect.  Use ildasm to disassemble the compiler output to see if this hypothesis is correct

20. Debugging Exercise – Step 6  The compiler is outputting the wrong instruction for <. Why?  Solution Examine the source code of the C# compiler Examine the source code of the C# compiler We find an error in the compiler source code for the ‘less than’ operator. We find an error in the compiler source code for the ‘less than’ operator.  Fix the error and retest The for loop now works The for loop now works The comparison and bubble sort still fail The comparison and bubble sort still fail

21. Debugging Exercise…  We don’t have time to show it, but there is an error in the SSCLI JIT compiler relating to floating point branch instructions  Students need to use similar debugging skills to discover and rectify this

22. Process  This exercise uses Rotor to confront some of the student’s preconceptions.  Most new graduates would: Not produce sufficient test cases to narrow the problem down to the floating point comparison Not produce sufficient test cases to narrow the problem down to the floating point comparison Not suspect the compiler of producing incorrect code Not suspect the compiler of producing incorrect code Think that they had not fixed the compiler after removing the bug Think that they had not fixed the compiler after removing the bug  The Rotor source is large and unfamiliar – exactly what they will face in the real world

23. Learning Outcomes  Importance of methodical approach  Design of test cases  Navigation of code base  Debugging tools  Disassembly tools  An introduction to intermediate language and Just-In-Time compilation

24. Summary  We feel that our.NET degree will significantly enhance the abilities of students and build on an undergraduate course  We are really looking forward to starting this course  It will be as interesting for us as it is for the students!