For developers who love to code. Compare between .NET folks and Java geeks. We are discussing what each platform present with pros and cons of each.

1. VS.
Abd El-Rahman Hosny Alaa Attyea M.

2. Agenda
- Previous State of Affairs.
- Introduction to Java
• Compilers vs. Interpreters.
• Platform-Dependency.
• Hybrid Compiler-Interpreter.
• Java Components (JDK).
• JIT Solution.
- The .NET Solution
• CLR, CTS and CLS.
• Base Class Library.
• .NET Sons.
- What’s Next?!

3.  Punched Cards
- Piece of paper, that contains digital information.
- Information is represented by the presence or absence of holes
in predefined positions.
Previous State of Affairs ..

4. Previous State of Affairs ..
 Assembly Programming
- More readable for programmers.
- Consists of machine instructions.
- Each computer architecture has its own assembly commands.
- Reduced Instruction Set Computing (RISC).
- Complex Instruction Set Computing (CISC).
- Using assembler: assembly code => executable machine code.
- However, still a low-level programming language.
- High-level assembler for assembly languages that have some
high-level programming features.

5. Previous State of Affairs ..

6. Previous State of Affairs ..
 C/Windows API
- To develop software for Windows operating systems, we use
C programming language with the Windows application
programming interface (API).
- Large number of applications already created with this
approach.
- However …
Manual memory management.
Ugly pointer arithmetic.
Spaghetti code (thousands of functions & data types).

7. Previous State of Affairs ..
 C++/MFC
- Object-oriented layer on top of C.
- Benefits of OOP (Encapsulation, Inheritance, Polymorphism)
- Microsoft Foundation Classes (MFC) are set of C++ classes
that facilitate building Windows applications.
- MFC hade the underlying Windows API and provide classes,
macros and code generation tools (wizards).
- However …
Backward compatibility with C makes it prone to the same
problems (memory management, pointers, constructs).

8. Previous State of Affairs ..
 Visual Basic 6.0
- Programmer is now able to build complex user interfaces and
code libraries.
- Can access databases easily.
- Hide Windows API by using code wizards, VB data types,
classes and VB-specific functions.
- However …
Not fully OO (rather it’s object-based).
No is-a relationship (No inheritance).
No Multi-threaded applications (actually we can use lower
level APIs.

9. Previous State of Affairs ..
 COM
- Stands for Component Object Model.
- Microsoft’s previous application development framework.
- “If you build your types in accordance with the rules of COM,
you end up with a block of reusable binary code”.
- Language-Independent.
- ATL ( Active Template Library) provides a set of C++ classes,
templates & macros.
- However … Complex Data Type representation

10. The Move ...

11. What is a program & how it runs ?!
Source code and native bits:
- Source code a series of related commands of specific programming languages.
- Actually source code is not what runs on our machines.
- Machines knows only it’s native language (0s&1s).
- Source code must be translated in some way to the machine native language.

12. Compilers Vs interpreters :
- Compilers and interpreters and some software that acts as
a translator between you (high level language) and the machine (low level
language).
- Actually compilers and interpreters are totally different in the ways how
they treat your code.
- Let’s take a look about how they are working.

13. What is interpreter ?!
- Interpreters doesn’t behave like compilers.
- It do not translate any programming commands, it takes the code and
executes it line by line.
- Examples for interpreted languages PHP, haskell, aslo shell command in
linux are interpreted.

14. Platform dependent problem:
- As there are different computer architectures there must exist different
compilers to translate the code.
- Here w have the platform dependent problem.
- However … There another solution for that problem called, hybrid compiler-
interpreter.
- In this case first there will be intermediate code, which will run over the
interpreter and we’ll get the result.

15. Hybrid Compiler-interpreter:

16. Java solution and the power of Java:
- Java has the same solution about that issue.
- After we have written our source code, when we compile it using the javac
command, it will generate the intermediate code or what is called byte code.
- This will be at the form of (.class) file.
- JRE can be responsible for running and executing the .class file over the
machine.

17. Java components:
- The first step to write a java program and run it is to set up something called
JDK (Java Development Kit).
- This includes three main component for java
• JRE (JVM is a part of it).
• Java compiler (javac).
• Java debugger.
- With the help of these component you can run your code wherever and whatever
the architecture or platform of your machine.

18. - After the programmer have written the source code, he’ll use the javac to
compile the (.java file)
- Then the javac will create an intermediate code that is known as (.class file)
or byte code.
- This byte code can run over any JVM regardless of the machine architecture
or platform.
How the Java Program Runs ?

19. - It is a set of dynamically loadable libraries that java application uses at run time.
Java Class Library

20. JCL serves three purposes within the Java Platform:
- They provide the programmer a well-known set of useful facilities.
- Provides an abstract interface to tasks that would normally depend heavily on
the hardware and operating system, such as network access and file access.
- Some underlying platforms may not support all of the features a Java
application expects. In these cases, the library implementation can either
emulate those features or provide a consistent way to check for the presence of
a specific feature.

21.  JIT:
- Java uses different ways to generate machine the machine code.
- There is a way to produce efficient machine code called JIT (Just In Time
compilation).
- JIT compilers promise to improve the performance of Java applications.
- Rather than letting the JVM run bytecode, a JIT compiler translates code into
the host machine’s native language.
- Thus, applications get the performance enhancement of compiled code while
maintaining Java’s portability.

22. Java Garbage collector:
- Objects are created in the heap.
- Garbage collector looks for those objects that are not referencing and
memory location and reclaim the heap from those objects.
- Garbage Collection in Java is carried by a daemon thread called Garbage
Collector.

23. - Interoperability with existing source code.
- Support for many programming language.
- Common run-time engine shared by all .NET-aware languages.
- Complete and total language integration.
- Comprehensive base class libraries.
- No COM.
- Simplified deployment model.
The .NET Solution

24. .NET Building Blocks
CLR
Common Language
Runtime
CTS
Common Type System
CLS
Common Language
Specification

25.  CTS (Common Type System)
- CTS Specification fully describes all possible data types and programming
constructs supported by the run-time.
- CTS specifies how these entities can interact with each other and how they are
represented in the .NET metadata format.
- Some .NET language might not support every feature defined by the CTS.

26.  CLS (Common Language Specification)
- CLS is a set of rules that describes, in detail, the minimal and complete set
of features a given .NET-aware compiler must support to produce code that
can be hosted by the CLR, while at the same time can be accessed in a
uniform manner by all languages that the .NET platform support.
- CLS is a subset of the full functionality of CTS.

27.  CLR (Common Language Runtime)
- The CLR locate, load and manage .NET types on your behalf.
- Memory Management (Garbage Collector).
- Application Hosting.
- Handling Threads.
- Security Checks.

28.  CLR (Common Language Runtime) .. cont.
- When an assembly is referenced for use, mscore.dll is loaded automatically, which
loads the required assembly in turn.
(MS Common Object Runtime Execution Engine).
- Creating the required custom types.
- The key assembly is the mscore.dll, which contains a large number of types, that
encapsulate a wide variety of common programming tasks as well as the core data
types used by all .NET languages.

29. - In addition to CLR and CTS/CLS specifications, the .NET platform provides a base
class library that is available to all .NET programming languages
Base Class Library

31. - CIL: the same as Java bytecode, it’ not compiled into platform specific instructions
until absolutely necessary.
- You can view the CIL code of any assembly using either:
ildasm.exe or using Reflector.

32. - Metadata
describes, in detail, the characteristics of every type within the
binary.
- Manifest:
The current version of the assembly.
Culture information (localizing string & image resources).
List of externally referenced assemblies that are required for
the proper execution of the program.
 Single-File assembly vs. Multi-File assembly.

34. - Applications running in a managed environment tend to require more system resources
than similar applications that access machine resources more directly
- Managed byte code can often be easier to reverse-engineer than native code.
- The .NET Framework currently does not provide support for calling Streaming SIMD
Extensions (SSE) via managed code.
- While the standards that make up .NET are inherently cross-platform, Microsoft's full
implementation of .NET is only supported on Windows.
Criticism

35. AbdelrahmanHosny.com
AlaaAttya.wordpress.com