.NET MSc in Distributed Systems

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

2. Overview • Teaching Undergraduate Computer Science • Traditional approaches • Challenges and opportunities • Making a .NET-based degree • Background, aims and content • 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 • Taught postgraduate degrees • Graphics and Visualization, Games Programming, Internet Computing

4. Undergraduate Computer Science • Our approach is fairly conventional: • Year One • Introduce broad range of underlying theory • Year Two • Extend Year One theory with more advanced topics and greater depth of content • Year Three • Individual specialism and further advanced topics • Large 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 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 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

7. .NET Degree – Aims & Content • Aims • Give advanced coverage of modern distributed computing techniques • Develop skills in working with large codebases • To develop “active practitioners” • Provide hands-on practical experience underpinned by advanced theoretical concepts • 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 • Diploma Stage • Advanced computing topics • Masters Stage • 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 • Custom Garbage Collection • Custom Remoting / object mobility • 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 • excellent environment for enhancing testing/ debugging skills • Not simply a .NET degree • 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 • 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?) • provide opportunities to develop debugging and testing skills • 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

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 • First they must convince themselves that their program is correct • 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 • Hypothesis • if it works in .NET our code must be valid • Outcome • 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 < 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. • 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 • 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 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 suspect the compiler of producing incorrect code • 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!