Zend Framework & MVC Introduction

Zend Framework & MVC Introduction

Zend Framework

Zend Framework is an open source, object oriented web application framework for PHP 5. Zend Framework is often called a 'component library', because it has many loosely coupled components that you can use more or less independently. But Zend Framework also provides an advanced Model-View-Controller (MVC) implementation that can be used to establish a basic structure for your Zend Framework applications. This QuickStart will introduce you to some of Zend Framework's most commonly used components, includingZend_Controller, Zend_Layout, Zend_Config, Zend_Db, Zend_Db_Table, Zend_Registry, along with a few view helpers.

these components, we will build a simple database-driven guest book application within minutes. The complete source code for this application is available in the following archives:

·         » zip

·         » tar.gz

Model-View-Controller

So what exactly is this MVC pattern everyone keeps talking about, and why should you care? MVC is much more than just a three-letter acronym (TLA) that you can whip out anytime you want to sound smart; it has become something of a standard in the design of modern web applications. And for good reason. Most web application code falls under one of the following three categories: presentation, business logic, and data access. The MVC pattern models this separation of concerns well. The end result is that your presentation code can be consolidated in one part of your application with your business logic in another and your data access code in yet another. Many developers have found this well-defined separation indispensable for keeping their code organized, especially when more than one developer is working on the same application.

Note: More Information

Let's break down the pattern and take a look at the individual pieces: 

·         Model - This is the part of your application that defines its basic functionality behind a set of abstractions. Data access routines and some business logic can be defined in the model.

·         View - Views define exactly what is presented to the user. Usually controllers pass data to each view to render in some format. Views will often collect data from the user, as well. This is where you're likely to find HTML markup in your MVC applications.

·         Controller - Controllers bind the whole pattern together. They manipulate models, decide which view to display based on the user's request and other factors, pass along the data that each view will need, or hand off control to another controller entirely

For more information, please visit : www.programmingyan.com

Haskell Programming Language

 Haskell Programming Language

Haskell is a standardized, general-purpose purely functional programming language, with non-strict semantics and strong static typing^. It is named after logician Haskell Curry^..

History

Following the release of Miranda by Research Software Ltd, in 1985, interest in lazy functional languages grew: by 1987, more than a dozen non-strict, purely functional programming languages existed. Of these, Miranda was the most widely used, but it was proprietary software. At the conference on Functional Programming Languages and Computer Architecture (FPCA '87) in Portland, Oregon, a meeting was held during which participants formed a strong consensus that a committee should be formed to define an open standard for such languages. The committee's purpose was to consolidate the existing functional languages into a common one that would serve as a basis for future research in functional-language design.

Haskell 1.0 to 1.4

The first version of Haskell ("Haskell 1.0") was defined in 1990. The committee's efforts resulted in a series of language definitions (1.0, 1.1, 1.2, 1.3, 1.4).

Haskell 98

In late 1997, the series culminated in Haskell 98, intended to specify a stable, minimal, portable version of the language and an accompanying standard library for teaching, and as a base for future extensions. The committee expressly welcomed the creation of extensions and variants of Haskell 98 via adding and incorporating experimental features.

In February 1999, the Haskell 98 language standard was originally published as "The Haskell 98 Report. In January 2003, a revised version was published as "Haskell 98 Language and Libraries: The Revised Report". The language continues to evolve rapidly, with the Glasgow Haskell Compiler (GHC) implementation representing the current de facto standard.

Features

Haskell features lazy evaluation, pattern matching, list comprehension, type classes, and type polymorphism. It is a purely functional language, which means that in general, functions in Haskell do not have side effects. There is a distinct construct for representing side effects, orthogonal to the type of functions. A pure function may return a side effect which is subsequently executed, modeling the impure functions of other languages.

Haskell has a strong, static type system based on Hindley–Milner type inference. Haskell's principal innovation in this area is to add type classes, which were originally conceived as a principled way to add overloading to the language, but have since found many more uses^\

The construct which represents side effects is an example of a monad. Monads are a general framework which can model different kinds of computation, including error handling, non determinism, parsing, and software transactional memory. Monads are defined as ordinary datatypes, but Haskell provides some syntactic sugar for their use.

The language has an open, published specification, and multiple implementations exist. The main implementation of Haskell, GHC, is both an interpreter and native-code compiler that runs on most platforms. GHC is noted for its high-performance implementation of concurrency and parallelism, and for having a rich type system incorporating recent innovations such as generalized algebraic data types and type families.

There is an active community around the language, and more than 5400 third-party open-source libraries and tools are available in the online package repository Hackage.

Code examples

The following is a Hello world program written in Haskell (note that all but the last line can be omitted):

module Main where

main :: IO ()

main = putStrLn "Hello, World!"

Here is the factorial function in Haskell, defined in a few different ways:

-- Type annotation (optional)

factorial :: (Integral a) => a -> a

-- Using recursion

factorial n | n < 2 = 1

factorial n = n * factorial (n - 1)

-- Using recursion, with guards

factorial n

  | n < 2     = 1

  | otherwise = n * factorial (n - 1)

-- Using recursion but written without pattern matching

factorial n = if n > 0 then n * factorial (n-1) else 1

-- Using a list

factorial n = product [1..n]

-- Using fold (implements product)

factorial n = foldl (*) 1 [1..n]

-- Point-free style

factorial = foldr (*) 1 . enumFromTo 1

An efficient implementation of the Fibonacci numbers, as an infinite list, is this:

-- Type annotation (optional)

fib :: Int -> Integer

-- With self-referencing data

fib n = fibs !! n

        where fibs = 0 : scanl (+) 1 fibs

        -- 0,1,1,2,3,5,...

-- Same, coded directly

fib n = fibs !! n

        where fibs = 0 : 1 : next fibs

              next (a : t@(b:_)) = (a+b) : next t

-- Similar idea, using zipWith

fib n = fibs !! n

        where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

-- Using a generator function

fib n = fibs (0,1) !! n

        where fibs (a,b) = a : fibs (b,a+b)

The Int type refers to a machine-sized integer (used as a list subscript with the !! operator), while Integer is an arbitrary-precision integer. For example, using Integer, the factorial code above easily computes "factorial 100000" as an incredibly large number of 456,574 digits, with no loss of precision.

This is an implementation of an algorithm similar to quick sort over lists, in which the first element is taken as the pivot:

quickSort :: Ord a => [a] -> [a]

quickSort []     = []                               -- The empty list is already sorted

quickSort (x:xs) = quickSort [a | a <- xs, a < x]   -- Sort the left part of the list

                   ++ [x] ++                        -- Insert pivot between two sorted parts

                   quickSort [a | a <- xs, a >= x]  -- Sort the right part of the list

Implementations

All listed implementations are distributed under open source licenses^.

The following implementations comply fully, or very nearly, with the Haskell 98 standard.

·         The Glasgow Haskell Compiler (GHC) compiles to native code on a number of different architectures—as well as to ANSI C—using C-- as an intermediate language. GHC has become the de facto standard Haskell dialect. There are libraries (e.g. bindings to OpenGL) that will work only with GHC. GHC is also distributed along with the Haskell platform.

·         The Utrecht Haskell Compiler (UHC) is a Haskell implementation from Utrecht University. UHC supports almost all Haskell 98 features plus many experimental extensions. It is implemented using attribute grammars and is currently mainly used for research into generated type systems and language extensions.

·         Jhc is a Haskell compiler written by John Meacham emphasising speed and efficiency of generated programs as well as exploration of new program transformations.

·         Ajhc is a fork of Jhc.

·         LHC is a whole-program optimizing backend for GHC. It is based on Urban Boquist’s compiler intermediate language, GRIN. Older versions of LHC were based on Jhc rather than GHC.

The following implementations are no longer being actively maintained:

·         Hugs, the Haskell User's Gofer System, is a bytecode interpreter. It used to be one of the most widely used implementations alongside the GHC compiler, but has now been mostly replaced by GHCi. It also comes with a graphics library.

·         nhc98 is another bytecode compiler. Nhc98 focuses on minimizing memory usage.

·         Yhc, the York Haskell Compiler was a fork of nhc98, with the goals of being simpler, more portable and more efficient, and integrating support for Hat, the Haskell tracer. It also featured a JavaScript backend, allowing users to run Haskell programs in a Web browser.

·         HBC is an early implementation supporting Haskell 1.4. It was implemented by Lennart Augustsson in, and based on, Lazy ML. It has not been actively developed for some time.

The following implementations are not fully Haskell 98 compliant, and use a language that is a variant of Haskell:

·         Gofer was an educational dialect of Haskell, with a feature called "constructor classes", developed by Mark Jones. It was supplanted by Hugs.

·         Helium is a newer dialect of Haskell. The focus is on making it easy to learn by providing clearer error messages. It currently lacks full support for type classes, rendering it incompatible with many Haskell programs.

For more information, please visit : www.programmingyan.com

SPARK (programming language)

SPARK (programming language)

SPARK is a formally defined computer programming language based on the Ada programming language, intended for the development of high integrity software used in systems where predictable and highly reliable operation is essential. It facilitates the development of applications that demand safety, security, or business integrity.

Originally, there were three versions of the SPARK language (SPARK83, SPARK95, SPARK2005) based on Ada 83, Ada 95 and Ada 2005 respectively.A fourth version of the SPARK language, SPARK 2014, based on Ada 2012, was released on April 30, 2014. SPARK 2014 is a complete re-design of the language and supporting verification tools.The SPARK language consists of a well-defined subset of the Ada language that uses contracts to describe the specification of components in a form that is suitable for both static and dynamic verification.

In SPARK83/95/2005, the contracts are encoded in Ada comments (and so are ignored by any standard Ada compiler), but are processed by the SPARK "Examiner" and its associated tools.

SPARK 2014, in contrast, uses Ada 2012's built-in "aspect" syntax to express contracts, bringing them into the core of the language. The main tool for SPARK 2014 (GNATprove) is based on the GNAT/GCC infrastructure, and re-uses almost the entirety of the GNAT Ada 2012 front-end.

Technical overview

SPARK aims to exploit the strengths of Ada while trying to eliminate all its potential ambiguities and insecurities. SPARK programs are by design meant to be unambiguous, and their behavior is required to be unaffected by the choice of Ada compiler. These goals are achieved partly by omitting some of Ada's more problematic features (such as unrestricted parallel tasking) and partly by introducing contracts which encode the application designer's intentions and requirements for certain components of a program.

The combination of these approaches is meant to allow SPARK to meet its design objectives, which are:

·         logical soundness

·         rigorous formal definition

·         simple semantics

·         security

·         expressive power

·         verifiability

·         bounded resource (space and time) requirements.

·         minimal runtime system requirements

Contract examples

Consider the Ada subprogram specification below:

procedure Increment (X : in out Counter_Type);

What does this subprogram actually do? In pure Ada, it could do virtually anything – it might increment the X by one or one thousand; or it might set some global counter to Xand return the original value of the counter in X; or it might do absolutely nothing with X at all.

With SPARK 2014, contracts are added to the code to provide additional information regarding what a subprogram actually does. For example, we may alter the above specification to say:

procedure Increment (X : in out Counter_Type)

  with Global => null,

       Depends => (X => X);

This specification tells us that the Increment procedure does not update or read from any global variables and that the only data item used in calculating the new value of X is X itself.

Alternatively, the designer might specify:

procedure Increment (X : in out Counter_Type)

  with Global  => (In_Out => Count),

       Depends => (Count  => (Count, X),

                   X      => null);

The second specification tells us that Increment will use some global variable called "Count" in the same package as Increment and that the exported value of Count is dependent on the imported values of Count and X, but that exported value of X does not depend on any variables at all – it will be derived simply from constant data.

If GNATprove is then run on the specification and corresponding body of a subprogram, it will analyse the body of the subprogram to build up a model of the information flow. This model is then compared against that which has been specified by the annotations and any discrepancies reported to the user.

We can further extend these specifications by asserting various properties that either need to hold when a subprogram is called (preconditions) or that will hold once execution of the subprogram has completed (postconditions). For example, we could say the following:

procedure Increment (X : in out Counter_Type)

  with Global  => null,

       Depends => (X => X),

       Pre     => X < Counter'Last,

       Post    => X = X'Old + 1;

This specification now says that not only is X only derived from itself, but that before Increment is called X must be strictly less than the last possible value of its type and that afterwards X will be equal to the initial value of X plus one – no more and no less.

Verification Conditions

GNATprove can also generate a set of Verification Conditions or VCs. VCs are used to attempt to establish certain properties hold for a given subprogram. At a minimum, the GNATprove will generate VCs attempting to establish that all run-time errors cannot occur within a subprogram, such as

·         array index out of range

·         type range violation

·         division by zero

·         numerical overflow.

If a postcondition or other assertions are added to a subprogram, GNATprove will also generate VCs that require the user to show that these properties hold for all possible paths through the subprogram.

Under the hood, GNATprove uses the Why3 intermediate language and VC Generator, and the Alt-Ergo theorem prover to discharge VCs. Use of other provers (including interactive proof checkers) is also possible through other components of the Why3 toolset.

History

The first version of SPARK (based on Ada 83) was produced at the University of Southampton (with UK  Ministry of Defence sponsorship) by Bernard Carré and Trevor Jennings. Subsequently the language was progressively extended and refined, first by Program Validation Limited and then by Praxis Critical Systems Limited. In 2004, Praxis Critical Systems Limited changed its name to Praxis High Integrity Systems Limited. In January 2010, the company became Altran Praxis.

In early 2009, Praxis formed a partnership with AdaCore, and released "SPARK Pro" under the terms of the GPL. This was followed in June 2009 by the SPARK GPL Edition 2009, aimed at the FLOSS and academic communities.

In June 2010, Altran-Praxis announced that the SPARK programming language would be used in the software of US Lunar project CubeSat, expected to be completed in 2015.

In January 2013, Altran-Praxis changed its name to Altran.

The first Pro release of SPARK 2014 was announced on April 30, 2014, and was quickly followed by the SPARK 2014 GPL edition, aimed at the FLOSS and academic communities.

Industrial applications Safety related systems

SPARK has been used in several high profile safety-critical systems, covering commercial aviation (Rolls-Royce Trent series jet engines, the ARINC ACAMS system, the Lockheed Martin C130J), military aviation (EuroFighter Typhoon, Harrier GR9, AerMacchi M346), air-traffic management (UK NATS iFACTS system), rail (numerous signalling applications), medical (the LifeFlow ventricular assist device), and space applications

Security related systems

SPARK has also been used in secure systems development. Users include Rockwell Collins (Turnstile and SecureOne cross-domain solutions), the development of the original MULTOS CA, the NSA Tokeneer demonstrator, the secunet multi-level workstation, and the Muen separation kernel.

In August 2010, Rod Chapman, principal engineer of Altran Praxis, implemented Skein, one of candidates for SHA-3, in SPARK. He wanted to compare the performance of the SPARK and C implementations. After careful optimization, he managed to have the SPARK version only about 5 to 10% slower than C. Later improvement to the Ada middle-end in GCC (implemented by Eric Botcazou of AdaCore) closed the gap, with the SPARK code matching the C in performance exactly.

For more information, please visit : www.programmingyan.com