'NET MSc in Distributed Systems

1
.NET MSc in Distributed Systems

• David Grey
• Rob Miles

• University of Hull, UK

2
Overview

• Where in the world is Hull?
• Teaching Undergraduate Computer Science
• Traditional approaches
• Challenges and opportunities
• Making a .NET-based degree
• Background, aims and content
• Working with Microsoft
• The role of .NET, SSCLI (Rotor) and AA programmes
• Example laboratory exercise

3
(No Transcript)
4
The World According to Us

• Hull is in England, east of York and further
  east of New York!

5
What is special about Hull?

• Hull
• Is a busy port city with direct connections to
  mainland Europe
• Around 265,000 inhabitants
• Is the birthplace of anti-slavery campaigner
  William Wilberforce
• Is the home of one half of the Humber Bridge
• Is the cucumber centre of Europe!

6
What about the University of Hull ?

• Founded in 1927 75 this year!
• 15,000 students from 100 countries
• Broad arts and science focus
• Graduates amongst the most employable in the U.K.
• Famous for ?
• Inventing liquid crystal technology
• The poet Philip Larkin, University librarian for
  over 30 years

7
Computing _at_ 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

8
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

9
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

10
The Inspiration

• At a Microsoft .NET event we were introduced to
  Rotor
• Rotor is a freely available version of .NET in
  source form which
• runs on Windows, FreeBSD and MacOS
• is properly known as the Shared Source Common
  Language Infrastructure
• We reckoned we could teach some serious Computer
  Science with this!

11
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

12
Working with Microsoft

• Access to Microsoft Engineers
• Helped us with technical aspects of the material
• Helped us ensure that the content of the course
  is directly relevant to the needs of industry
• Microsoft is now working hard with the Higher
  Education sector to help us achieve our goals

13
Microsoft Programmes

• Microsoft are making our job easier
• MSDN AA
• Makes most Microsoft tools freely available to
  staff and students for teaching/research purposes
• Shared Source Programme
• Gives us access to source code of key products
  (e.g. operating systems, SSCLI)

14
.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

15
Degree Structure

• Three stages
• Certificate Stage
• Skills to underpin the original work
• Diploma Stage
• Advanced computing topics
• Masters Stage
• Practical deployment of techniques

16
Certificate Stage
17
Diploma Stage
18
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

19
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

20
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 doesnt work!

21
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

22
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

23
Debugging Exercise Step 2

• Compile and run the program using the Rotor C
  compiler and the Rotor CLR
• 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

24
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

25
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 lt operator
• Write some simple programs to test these
  hypotheses

26
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

27
Debugging Exercise Step 6

• The compiler is outputting the wrong instruction
  for lt. 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

28
Debugging Exercise Step 7

• Hypotheses
• If our source code is correct and the generated
  IL is correct, the Rotor CLR must be
  malfunctioning
• The malfunction relates to the lt operator.
• Approach
• Does the comparison test fail for different data
  types (e.g. integers)?
• No the error only occurs in floating point
  comparisons. Note that compiler turns lt into
  bge_un_s

29
Debugging Exercise Step 8

• We have the CLR source where do we begin?
• The CLR has a JIT compiler which
• compiles IL to native code on the fly
• would be a good place to start looking
• perhaps something goes wrong in JITing the
  comparison
• Which source file(s) contain the JIT compiler?

30
Debugging Exercise Step 9

• Start with fjit.cpp.
• Are there any references to BGE_UN_S?
• Yes - a switch statement with opcodes
• Manually trace all calls from here
• End up in CLT_R8_helper which
• implements the comparison
• has an error lt should be lt

31
Debugging Exercise Step 10

• Solution
• Alter the lt to lt
• Recompile and test
• Success! All our tests and the bubble sort now
  work

32
Process

• This exercise uses Rotor to confront some of the
  students 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

33
Learning Outcomes

• Importance of methodical approach
• Design of test cases
• Navigation of code base
• Debugging tools
• Disassembly tools
• An introduction to intermediate language
• Just-In-Time compilation

34
Summary

• We feel that our .NET degree will significantly
  enhance the abilities of students and build on an
  undergraduate course
• The involvement of Microsoft is crucial
• We are really looking forward to starting this
  course

35
(No Transcript)
36
Programming Poetry

• We will be presenting a sponsored technical
  lecture in rhyme on 14th of March 2003 it is a
  Hull tradition
• This year the subject will be .NET
• To find out more visit
• www.lectureinrhyme.com