comparing and contrasting c#, scheme, and t-sql

56
Comparing and Contrasting C#, Scheme, and T-SQL Joseph P. Mohr

Upload: murray

Post on 26-Feb-2016

77 views

Category:

Documents


0 download

DESCRIPTION

Comparing and Contrasting C#, Scheme, and T-SQL. Joseph P. Mohr. Outline. C# Overview Scheme Overview T-SQL Overview Language Comparisons Conclusions. C# Overview. Object-Oriented Language Type-Safe Evolved from C Main application is server-side scripting in the .NET Framework - PowerPoint PPT Presentation

TRANSCRIPT

Page 1: Comparing and Contrasting C#, Scheme, and  T-SQL

Comparing and Contrasting C#, Scheme, and T-SQL

Joseph P. Mohr

Page 2: Comparing and Contrasting C#, Scheme, and  T-SQL

1. C# Overview2. Scheme Overview3. T-SQL Overview4. Language Comparisons5. Conclusions

Outline

Page 3: Comparing and Contrasting C#, Scheme, and  T-SQL

Object-Oriented Language Type-Safe Evolved from C Main application is server-side scripting in

the .NET Framework Developed in 2001 Current version is 4.0

C# Overview

Page 4: Comparing and Contrasting C#, Scheme, and  T-SQL

C# is designed for component-oriented programming

Software Components◦ Increasingly used in modern software design◦ Self-contained and self-describing◦ Have their own documentation

C# Advantages

Page 5: Comparing and Contrasting C#, Scheme, and  T-SQL

Versioning◦ Allows the language to evolve without breaking

programs in older versions.◦ Supports virtual and override modifiers. ◦ Method overloading that supports versioning.◦ Explicit interface member declarations.

C# Advantages

Page 6: Comparing and Contrasting C#, Scheme, and  T-SQL

Virtual and Override◦ If a method is declared virtual, then the

implementation evokes is determined at run-time.◦ Non-Virtual methods have the implementation

determined at compile-time.◦ The override modifier can be used to provide

another implementation for an existing virtual method.

C# Advantages

Page 7: Comparing and Contrasting C#, Scheme, and  T-SQL

C# programs are comprised of the following:◦ Programs◦ Namespaces◦ Types◦ Members◦ Assemblies

C# Program Structure

Page 8: Comparing and Contrasting C#, Scheme, and  T-SQL

Consist of one or more source files Source files contain the other structural

elements of the program

C# Programs

Page 9: Comparing and Contrasting C#, Scheme, and  T-SQL

Declared at the top of the source file with the using directive

Avoid having to use the fully qualified names in the source code.

C# Namespaces

Page 10: Comparing and Contrasting C#, Scheme, and  T-SQL

Most common types:◦ Classes◦ Interfaces

Can contain members and namespaces Either reference or value With reference type, two variables can

affect the same object.

C# Types

Page 11: Comparing and Contrasting C#, Scheme, and  T-SQL

Most common members:◦ Fields◦ Methods◦ Properties◦ Events

C# Members

Page 12: Comparing and Contrasting C#, Scheme, and  T-SQL

Made up of Intermediate Language (IL) and metadata

Use Just-In-Time (JIT) compiling Implement applications or libraries and

have the .exe or .dll file extension respectively

C# Assemblies

Page 13: Comparing and Contrasting C#, Scheme, and  T-SQL

Using System;Class Hello{

Static void Main() {Console.Out.WriteLine(“Hello, World”);

}}

C# Hello World Program

Page 14: Comparing and Contrasting C#, Scheme, and  T-SQL

C# uses two different grammars, the Lexical grammar and the syntactic grammar.

Lexical grammar defines line terminators, white space, comments, tokens, and preprocessing directives.

Syntactic grammar defines how the tokens from the lexical grammar are combined into programs.

C# Grammars

Page 15: Comparing and Contrasting C#, Scheme, and  T-SQL

Compiled language results in fast execution. High performance is a result of being

derived from the C family. Boxing and Unboxing operations are the

most common detriments to performance.◦ Can be avoided by declaring as Object

C# Performance

Page 16: Comparing and Contrasting C#, Scheme, and  T-SQL

Pros:◦ Clearly defined data types◦ Familiar, well designed syntax

Cons:◦ Feature multiplicity◦ Operator Overloading

C# Readability

Page 17: Comparing and Contrasting C#, Scheme, and  T-SQL

Pros:◦ Excellent support for abstraction◦ Strong expressivity with control sections

Cons:◦ Large number of different contstructs

C# Writability

Page 18: Comparing and Contrasting C#, Scheme, and  T-SQL

Classes derived from the base Object Class, which includes implementation of the primitives, can be simply combined to create very robust and diverse data structures.

C# Orthogonality

Page 19: Comparing and Contrasting C#, Scheme, and  T-SQL

Type-Checking:◦ C# is considered a type-safe language and the

compiler can catch type errors in almost all cases.◦ There are pointers supported by the language

which can prevent the compiler from catching type-errors.

Exception Handling:◦ Highly functional and similar to Java

C# Reliability Pros

Page 20: Comparing and Contrasting C#, Scheme, and  T-SQL

Aliasing:◦ Reference types can be referring to the same

memory location and is considered a detriment to reliability.

C# Reliability Cons

Page 21: Comparing and Contrasting C#, Scheme, and  T-SQL

The modular design considerations of C# makes the code highly portable.

Self-contained documentation in all the modules makes for easier portability amongst different software developers.

C# Portability

Page 22: Comparing and Contrasting C#, Scheme, and  T-SQL

MS Visual C# MS Visual Studio

C# Tools and Compilers

Page 23: Comparing and Contrasting C#, Scheme, and  T-SQL

using System;using System.Collections.Generic;using System.Linq;using System.Web;using System.Web.UI;using System.Web.UI.WebControls;

namespace WebApplication2{ public partial class _Default : System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) {

} protected void Calendar1_DayRender(object sender, DayRenderEventArgs e) { EventDataContext edc = new EventDataContext();

var query = from ev in edc.Events where ev.Date == e.Day.Date select ev;

C# Personal Example

Page 24: Comparing and Contrasting C#, Scheme, and  T-SQL

e.Cell.VerticalAlign = VerticalAlign.Top; e.Cell.BorderColor = System.Drawing.Color.Teal; e.Cell.BorderWidth = 1; e.Cell.BorderStyle = BorderStyle.Solid;

foreach (var ev in query) { HyperLink link = new HyperLink(); link.ForeColor = System.Drawing.Color.Teal; link.NavigateUrl = "~/EventInfo.aspx?event=" + ev.EventNo; link.Text = ev.Name; Button but = new Button(); e.Cell.Controls.Add(new LiteralControl("<p>")); e.Cell.Controls.Add(link); e.Cell.Controls.Add(new LiteralControl("</p>")); } } }}

C# Personal Example Contd.

Page 25: Comparing and Contrasting C#, Scheme, and  T-SQL

www.myjaxcalendar.com

C# Demo

Page 26: Comparing and Contrasting C#, Scheme, and  T-SQL

Functional programming language Evolved from LISP Created in 1975 at MIT by Guy L. Steele and

Gerald J. Sussman Originally called Schemer to mimic the

naming convention used by other languages evolved from LISP, such as Conniver

Considerably more minimalist than Common Lisp, but supports tools for language extension.

Scheme Overview

Page 27: Comparing and Contrasting C#, Scheme, and  T-SQL

Most commonly used for lambda calculus and as an educational tool by introductory level computer science classes.

Lambda calculus is a logical system of computation through the use of binding and substitution.

Scheme Applications

Page 28: Comparing and Contrasting C#, Scheme, and  T-SQL

Scheme programs are interpreted. Program Elements:

◦ Keywords ◦ Variables◦ Structured forms ◦ Constant data (numbers, characters, strings,

quoted vectors, quoted lists, quoted symbols, etc.)

◦ Whitespace◦ Comments

Program expressions are known as s-expressions

Scheme Programs

Page 29: Comparing and Contrasting C#, Scheme, and  T-SQL

S-expressions are made up of structured forms and lists.

S-expressions are delineated by matching sets of opening and closing parentheses.

Scheme Syntax

Page 30: Comparing and Contrasting C#, Scheme, and  T-SQL

List-processing primitives:◦ car – the first element in a list◦ cdr – all the other elements in the list◦ cons – constructs lists

First-class functions (functions can be assigned to variables)

Scheme Primitives and Variables

Page 31: Comparing and Contrasting C#, Scheme, and  T-SQL

Only the inner-most binding of a variable is visible in an expression.

Inner bindings are said to “shadow” the outer bindings.

This type of scoping is known as “lexical scoping”.

Scheme Variable Scoping

Page 32: Comparing and Contrasting C#, Scheme, and  T-SQL

Expression:◦ (cdr (car ‘((1 2 3) 4 5)))

Result:◦ (2 3)

Scheme Example Expression

Page 33: Comparing and Contrasting C#, Scheme, and  T-SQL

Scheme executes faster and more efficiently than Common LISP as a result of its minimalist design.

Scheme Performance

Page 34: Comparing and Contrasting C#, Scheme, and  T-SQL

Pros:◦ Overall Simplicity of the language, including a

lack of feature multiplicity, improves the readability of the language.

◦ Identifiers are not restricted in length. Cons:

◦ The dynamic variable types which aren’t explicitly declared to be of a certain data type.

Scheme Readability

Page 35: Comparing and Contrasting C#, Scheme, and  T-SQL

Pros:◦ The overall simplicity of the language, especially

over that of Common LISP Cons:

◦ Weak support for abstraction◦ Lacking expressivity

Scheme Writability

Page 36: Comparing and Contrasting C#, Scheme, and  T-SQL

Simply supports the most commonly used data structures including Strings and Enums.

Lacking in the ability to combine primitives in to complex data structures.

Scheme Orthogonality

Page 37: Comparing and Contrasting C#, Scheme, and  T-SQL

Pros:◦ Lack of aliasing◦ Performs run-time type checking

Cons:◦ Does not have a good system for exception

handling.

Scheme Reliability

Page 38: Comparing and Contrasting C#, Scheme, and  T-SQL

Scheme programs are highly portable between the same version of Scheme.

The very high number of versions of Scheme in use is major stumbling block to the portability of Scheme.

Scheme Portability

Page 39: Comparing and Contrasting C#, Scheme, and  T-SQL

Some of the many flavors of scheme are:◦ SISC – runs off of the JVM◦ DrRacket – Student friendly interface◦ MIT Scheme – very widely used

Scheme Flavors

Page 40: Comparing and Contrasting C#, Scheme, and  T-SQL

Scheme Demo

Page 41: Comparing and Contrasting C#, Scheme, and  T-SQL

Query Language Uses statements that are interpreted by the

database server. Used with relational databases

◦ Relational databases are based off of first order predicate logic.

Used by MS SQL Server database and Sybase database.

Main application is the construction and manipulation of enterprise databases.

T-SQL Overview

Page 42: Comparing and Contrasting C#, Scheme, and  T-SQL

History:◦ Evolved from SEQUEL.◦ SEQUEL (Structured English Query Language) is a

query language developed by IBM in the 1970’s and they later renamed it to SQL (Structured Query Language)

◦ T-SQL (Transact SQL) is an extension to SQL developed by a partnership between Microsoft and Sybase.

T-SQL Overview

Page 43: Comparing and Contrasting C#, Scheme, and  T-SQL

Data in relational databases are comprised of entity types

Entity Types are collections of the of the entities and thought type and are represented as TABLES.

Each instance of that entity is a record or tuple and is represented as a row in the table.

Records are comprised of different attributes, and they are represented as columns in the table.

T-SQL Overview

Page 44: Comparing and Contrasting C#, Scheme, and  T-SQL

T-SQL is technically a data-sublanguage The T-SQL sublanguage is comprised of the

following:◦ Data Definition Language (DDL)◦ Data Manipulation Language (DML)

T-SQL Overview

Page 45: Comparing and Contrasting C#, Scheme, and  T-SQL

The DML is used to define database structure, integrity rules, and user privileges.

Includes the following commands:◦ CREATE TABLE, DROP TABLE, ALTER TABLE◦ CREATE VIEW, DROP VIEW◦ CREATE INDEX, DROP INDEX

T-SQL DML

Page 46: Comparing and Contrasting C#, Scheme, and  T-SQL

The DML is used to manipulate the data within the database.

DML Commands Include:◦ SELECT◦ INSERT◦ UPDATE◦ DELETE

T-SQL DML

Page 47: Comparing and Contrasting C#, Scheme, and  T-SQL

T-SQL extends SQL to include:◦ Procedural Programming◦ Local Variables◦ Support functions for processing various data

types The extensions included in T-SQL grant it

equivalent capabilities to other programming languages.

T-SQL Extensions

Page 48: Comparing and Contrasting C#, Scheme, and  T-SQL

Flow control in T-SQL:◦ Begin◦ End◦ Break◦ Continue◦ GOTO◦ IF◦ ELSE◦ RETURN◦ WHILE◦ WAITFOR

T-SQL Extensions

Page 49: Comparing and Contrasting C#, Scheme, and  T-SQL

T-SQL contains try-catch blocks, unlike SQL Example:

BEGIN TRY//STATEMENTS

END TRYBEGIN CATCH

//STATEMENTS TO HANDLE EXCEPTIONEND CATCH

T-SQL Exception Handling

Page 50: Comparing and Contrasting C#, Scheme, and  T-SQL

T-SQL Demo

Page 51: Comparing and Contrasting C#, Scheme, and  T-SQL

T-SQL performs queries and data manipulation very efficiently across a wide variety of data types.

T-SQL Efficiency

Page 52: Comparing and Contrasting C#, Scheme, and  T-SQL

Readability:◦ High overall simplicity. Lack of multiplicity and

overloading.◦ Excellent facilities for defining data types◦ Form indicates meaning

Writability:◦ More expressive than SQL◦ Poor Abstraction

T-SQL Simplicity

Page 53: Comparing and Contrasting C#, Scheme, and  T-SQL

T-SQL supports a wide variety of primitive data types

The primitive data types can be easily combined in tables to easily create new data structures.

T-SQL Orthogonality

Page 54: Comparing and Contrasting C#, Scheme, and  T-SQL

Type-Checking:◦ Data must be of the appropriate type for a

statement to execute. Exception-Handling:

◦ T-SQL provides for exception handling, unlike SQL.

T-SQL Reliability

Page 55: Comparing and Contrasting C#, Scheme, and  T-SQL

Modularity and portability are a common and touted attribute amongst the languages, but C# achieves this goal to a greater extent than the others.

C# does not support shadowing like Scheme does.

All three languages are supported cross-platform.

Language Comparisons

Page 56: Comparing and Contrasting C#, Scheme, and  T-SQL

I drew the following conclusions my research in to these three languages:◦ Studying different types of languages increased

my ability to select an appropriate language for a given task.

◦ As I learned more languages, I was able to pick up new languages faster.

◦ Due to the similarities between the languages, studying C# improved my knowledge of Java.

◦ Many projects are best implemented through the use of multiple languages.

Concluding Remarks