Java SE 7 is a major release that has brought many new features and enhancements in Java programming. A brief introduction to the noteworthy features of Java SE 7 is as follows:

Swing enhancements: Introduce various enhancements in the javax.swing package. Some of such enhancements are as follows:

• Providing the JLayer class to decorate the swing components
• Moving Nimbus look and feel from the com.sun.java.swing package to the javax.swing.plaf.nimbus package
• Allowing mix up of heavyweight and lightweight components
• Allowing you to create translucent and shaped windows
• Adding the selection of Hue-Saturation-Luminance (HSL) color in the JColorChooser class

Enhancements in Java Input/Output (I/O): Introduce various enhancements in implementing I/O operations using Java programming. Some of the Java I/O enhancements in Java SE 7 are as follows:

• Allowing non-blocking I/O (NIO) 2.0
• Allowing you to develop customized file system provider
• Allowing you to manipulate contents of the Java Archive (JAR) file
• Introducing the new APIs in the java.nio.file package

Networking enhancements: Add the close() method in the URLClassLoader class. The introduction of this method has overcome the problem of supporting the updated implementations of resources that are taken up from a specific codebase. Moreover, the Sockets Direct Protocol (SDP) specifies the accessibility to high-performance network connections.

Security enhancements: Add the following security features in Java SE 7:

• Introducing Elliptic Curve Cryptography (ECC) as a new native provider that contains various ECC-based algorithms
• Allowing you to disable weak cryptographic algorithms

Multithreaded custom class loaders: Modify the locking mechanism to prevent deadlock situation, as the custom class loaders were initially prone to deadlocks

Enhancements in Java programming language: Introduce the following various enhancements in Java SE 7 as a programming language:

• Allowing you to specify the integral types, such as byte, short, int, and long, using the binary number system by adding the 0b or 0B prefix
• Allowing the use of underscores in the numerical literals
• Allowing the use of strings in the switch statements
• Improving the compiler warning that occurs while using non-reifiable formal parameters with the Varargs methods

Tags in a ticket-tracking application are extremely useful for making similar tickets easier to find and manage. In this article, we will create the interface for adding tags to a new ticket. This involves adding a new field to the new ticket page and defining a has_and_belongs_to_many association between the Ticket model and the not-yet existent Tag model.

Creating tags feature

For this feature, we’re going to add a text field beneath the description field on the new ticket page, just like we see in figure below:

The words we enter into this field will become the tags for this ticket and we should see them on the ticket page. At the bottom of features/creating_tickets.feature, we’ll add a scenario that creates a new ticket with tags, shown in listing 1.

Listing 1 features/creating_tickets.fetature

     Scenario: Creating a ticket with tags

     When I fill in “Title” with “Non-standards compliance”
     And I fill in “Description” with “My pages are ugly!”
     And I fill in “Tags” with “browser visual”
     And I press “Create Ticket”
     Then I should see “Ticket has been created.”
     And I should see “browser” in “#ticket #tags”
     And I should see “visual” in “#ticket #tags”

When we run this scenario using bundle exec cucumber, it will fail features/creating_tickets.feature:48 declaring that it can’t find the “Tags” field. Good! It’s not there yet.

And I fill in “Tags” with “browser visual”

     cannot fill in, no text field, text area or password field
        with id, name, or label ‘Tags’ found (Capybara::ElementNotFound)

We’re going to need to take the data from this field and process each word into a new Tag object and, for that reason, we’ll use a text_field_tag to render this field. text_field_tag is similar to a text_field tag, but it doesn’t have to relate to any specific object like text_field does; instead it will just output an input tag with the type attribute set to “text” and the name set to whatever name we give it.

Using text_field_tag

To define this field, we will put the following code underneath the p tag for the description in app/views/tickets/_form.html.erb.

<p>
     <%= f.label_tag :tags %>
     <%= f.text_field_tag :tags, params[:tags] %>
</p>

This field will be sent through to TicketsController as simply params[:tags]. By specifying params[:tags] as the second argument to this method, we can repopulate this field when the ticket cannot be created due to it failing validation.

When we re run this scenario, it no longer complains about the missing “Tags” field, but now that it can’t find the tags area for our ticket:

And I should see “browser” within “#ticket #tags”
scope ‘//*[@id = ‘ticket’]//*[@id = ‘tags’]’ not found …

We will need to define a #tags element inside the #ticket element so that this part of the scenario will pass. This element will contain the tags for our ticket, which our scenario will assert as actually visible.

Showing tags

We can add this new element to app/views/tickets/show.html.erb by adding this simple line underneath where we render the ticket’s description:

     <div id=‘tags’><%= render @ticket.tags %></div>

This creates the #ticket #tags element our feature is looking for and will render the soon-to-be-created app/views/tags/_tag.html.erb partial for every element in the also-soon-to-be-created tags association on the @ticket object.

So what out of these two steps is our next one? We can run our scenario again to see that it cannot find the tags method for a Ticket object:

     undefined method `tags’ for #<Ticket:0×0..

This method is the tags method, which we’ll be defining with a has_and_belongs_to_many association between Ticket objects and Tag objects. It will be responsible for returning a collection of all the tags associated with the given ticket, much like a has_many would. It works in the opposite direction also: allowing us to find out what tickets have a specific tag.

Defining the tags association

We can define the association has_and_belongs_to_many on the Ticket model by using this line, placed after a new line after the has_many definitions inside our Ticket model:

     has_and_belongs_to_many :tags

This association will rely on a join table that doesn’t yet exist, called tags_tickets. This table contains only two fields, which are both foreign keys for tags and tickets. By using a join table, many tickets can have many tags, and vice versa.

     When we rerun our scenario we’re told that there’s no constant called Tag yet:

     uninitialized constant Ticket::Tag (ActionView::Template::Error)

In other words, there is no Tag model yet. We should define this now if we want to go any further.

The Tag model

Our Tag model will have a single field called name which should be unique. To generate this model and its related migration we will run the rails command like this:

     rails g model tag name:string –timestamps false

The timestamps option passed here determines whether or not the model’s migration is generated with timestamps. Because we’ve passed the value of false to this, there will be no timestamps added.

Before we run this migration, we will need to add the join table called tags_tickets to our database, which has two fields: one called ticket_id and the other tag_id. The table name is the pluralized names of the two models it is joining, sorted in alphabetical order. This table will have no primary key as we only need it to join the tags and tickets table. We are never going to look for individual records from this table.

To define the table we will put this tags_tickets in the self.up section of our db/migrate/[timestamp]_create_tags.rb migration:

     create_table :tags_tickets, :id => false do | t |
        t.integer :tag_id, :ticket_id
     end

The : id => false option passed to create_table here tells Active Record to create the table without the id field.

We should also add drop_table :tag_tickets to the self.down method in this migration too so that, if we need to, we can undo this migration. Next, we will run the migration on our development database by running rake db:migrate and our test database by running rake db:test:prepare. This will create the tags and tags_tickets tables. When we run this scenario again with bundle exec cucumber features/creating_tickets:48, it is now satisfied that the tags method is defined and has now moved on to whining that it can’t find the tag we specified:

     And I should see “browser” within “#ticket #tags”
        Failed assertion, no message given. (MiniTest::Assertion)

This is because we’re not doing anything to associate the text from the “Tags” field to the ticket we’ve just created. We need to parse the content from this field into new Tag objects and then associate them with the ticket we are creating, which we’ll look at how to do right now.

Displaying a ticket’s tags

The params[:tags] in TicketsController’s create is the value from our “Tags” field on app/views/tickets/_form.html.erb. This is also the field we need to parse into Tag objects and associate them with the Ticket object we are creating.

To do this, we will alter the create action by adding this line directly after @ticket.save:

@ticket.tag!(params[:tags])

This method will parse the tags from params[:tags], convert them into new Tag objects, and associate them with the ticket. We can define this new method at the bottom of our Ticket model like this:

def tag!(tags)
tags = tags.split(“ “).map do |tag|
     Tag.find_or_create_by_name(tag)
   end
   self.tags << tags
end

On the first line here, we use the split method to split our string into an array, and then the map method to iterate through every value in the array. Inside the block for map, we use a dynamic finder to find or create a tag with a specified name. find_or_create_by methods will always return a record, whether it be a preexisting or a recently created one.

After all the tags have been iterated through, we assign them to a ticket by using the << method on the tags association. The tag! method we have just written will create the tags that we will display on the app/views/tickets/show.html.erb view by using this line:

     <%= render @ticket.tags %>

When we run this scenario again by running bundle exec cucumber features/creating_tickets.feature:48, we will see it’s this line that is failing with an error:
Missing partial tags/tag …

Therefore, the next step is to write the tag partial, which our feature has just complained about. To do this, we will put the following code in app/views/tags/_tag.html.erb:

     <span class=‘tag’><%= tag.name %></span>

By wrapping the tag name in a span with the of tag, class, it will be styled as defined in our stylesheet. With this partial defined, this puts the final piece of the puzzle for this feature into place. When we run our scenario again by running bundle exec cucumber features/creating_tickets.feature:48 it passes:

     1 scenario (1 passed)
     15 steps (15 passed)

Great! This scenario is now complete. When a user creates a ticket, they are able to assign tags to that ticket and they display along with the ticket’s information on the show action for TicketsController.

We will now commit this change, but, of course, before we do, we’ll ensure that we haven’t broken anything by running rake cucumber:ok spec.

     53 scenarios (53 passed)
     620 steps (620 passed)
     # and
     27 examples, 0 failures, 10 pending

Good to see that nothing’s blown up this time. Let’s commit this change.

     git add .
     git commit -m “Users can tag tickets upon creation”
     git push

Now that users are able to add a tag to a ticket when that ticket’s being created, we should also let them add tags to a ticket when they create a comment as well.

When a ticket’s discussion happens, new information may come about that would require that another tag be added to the ticket to group it into a different set. A perfect way to let our users do this would be to let them add it when they comment.

Summary

We’ve covered how to use a has_and_belongs_to_many association to define a link between tickets and tags. Tickets are capable of having more than one tag, but a tag is also capable of having more than one ticket assigned to it and, therefore, we use this type of association. A has_and_belongs_to_many could be used to associate people and the locations they’ve been.

SQA can be defined as a conformance to software requirement specification. SQA convinces that quality standards will be followed throughout the software development process and all the implicit as well as explicit requirements will be met. The idea of quality assurance came into being at Bell Labs in 1916, which is followed by quality control approaches in 1940. Nowadays, every software company focuses on software quality and invests a lot of money and resources in managing the quality of the software product. All the persons in an organization somehow contribute for SQA. Thus, a group of persons contributing toward the quality of the software product is known as SQA group. The group handles some of the following SQA activities:

• Planning
• Record keeping
• Analysis
• Reporting

SQA group also takes the responsibility to prepare an SQA plan, which is the basis for all SQA activities. The plan describes the following tasks:

• Product evaluation activities
• Audit and review of the product
• Quality standards for the product
• Error tracking and handling mechanism
• Document preparation
• Feedback to the software team

SQA or standards are the basis of effective quality management. The standards can be international, national, or organizational. Standards can be considered at the following two levels:

• Product standards: Define the characteristics that all components of the product should produce
• Process standards: Define the mechanism in which the software process should be constituted

However, product and process standards are not seen as relevant and up-to-date by software engineers. The relation between the software processes and product quality is complex and   poorly understood. Software process is very much responsible for the software product quality. A predefined process is repeatedly followed for the hardware development. Contrary to hardware development process, it is more complex to manage the software development process because the application of individual skills and experience is particularly important in software development. The important software quality assurance measures are constructive, analytical, and organizational measures.

The constructive measures ensure the following concerns:

• There is consistent application of methods in all the phases of development process
• The development tools are used suitably
• The development of software is based on high-quality and semi-finished products
• The development documentation is maintained

The analytical measures ensure the following concerns:

• There is static as well as dynamic program analyses
• Adequate test cases are systematically chosen
• The analysis results are maintained consistently

The organizational measures ensure the following concerns:

• The software developers should be informed and educated about the new technologies
• The quality assurance should be maintained

The quality assurance parameters are as follows:

• Quality of external documentation
• Programming language
• Availability of tools
• Programmer experience in data processing
• Programmer experience in the functional area
• Effect of project communication
• Independent modules for individual assignment
• Realize the requirements of the user

Therefore, to determine the appropriate level of Quality Assurance/Quality Control (QA/QC) resources and effort to be allocated, one needs to determine the acceptable level of risk.

The origin of defect in software development process lies in different stages of software development. The statistics of distribution of defects over phases are as follows:

• Requirement phase: 7%
• Design phase: 14%
• Code phase: 49%
• Others: 30%

Most organizations admit that their testing has the following drawbacks:

• Frequently ad hoc
• Poorly documented
• Inconsistently executed
• Primarily manual
• Limited in scope

Approaches to Software Quality Assurance

SQA is a consequence of a problem that came into existence due to poor quality of the software.  For the past three decades, software industry is going through software crisis and poor quality software. SQA is an activity that is followed throughout the software development cycle, that is, analysis, design, coding, and testing. It ensures software quality as per the software engineering standards through the application of an FTR mechanism, a thorough testing strategy, and better control over software products. SQA suggests quality in terms of measurable factors, indices, and metrics.

A number of software engineering institutes are looking forward to a more structured and formal approach to SQA. It is suggested that there must be mechanism that should rely on requirement model, programming languages, and mathematical methods to make sure that the software is fulfilling all its specifications and is up to the quality standards.

Reliability

Software reliability is another aspect to ensure software quality. Reliability refers to the ability of the software system to perform its intended functions satisfactorily and correctly as expected by the user. It gives a measure of correctness and robustness of the system. Robustness measures the degree of the software system to perform correctly on occurrence of some unexpected or unrealized situation. Software reliability cannot be measured directly. It is measured on the basis of related factors, such as faults, defects, and failures identified, that affect the reliability of a software system.

Software reliability can be measured using the following three measurement matrices:

• Product metrics: Apply to reliability of the software product. Size of the software reflects the degree of complexity, development effort involved, and reliability of the software. Lines of Code (LOC), or KLOC, are used as metrics to measure the software size. Typically, source code is measured in Source Lines of Code (SLOC) or Thousand Source Lines of Code (KSLOC) and instructions are counted, but the comments and other non-executable statements are not counted. Function point metric is another method used for measuring the functionality of a specified software system. It is based on the number of inputs to the system, outputs from the system, master files used with the system, and interfaces to the system. The method can also be applied to measure the size of a software system. It gives an indication about the functional complexity of the software system. There is a method called complexity-oriented metrics that is used to measure the complexity of a software system in terms of its control structure. This method is applied by representing the program code in a graphical manner. Another metrics applied for estimating the faults and reliability of a system is the test coverage metrics in which different tests are performed on the software product.

• Project metrics: Apply to the reliability of the processes applied for the management of project and development of the software. Higher reliability can be achieved by applying more effective methods for software development and project management.

• Process metrics: Apply to the reliability of software processes applied for development. Process metrics can also be applied to ensure quality.

There are different techniques that can be applied to improve the reliability of the software. The software needs to be verified, validated, and thoroughly tested before being deployed to ensure reliability. Testing helps in identifying any defects that may exist in the system. The defects identified can then be removed from the software by making proper modifications to ensure failure-free execution and user-desired reliability.

Filed under: Dreamtech Books, Dreamtech Engineering Textbooks Tagged: dreamtech, Dreamtech Books, dreamtech press, dreamtechpress, kogent learning solutions, kogent learning solutions inc, software engineering, software quality assurance ]]> http://dreamtechpress.wordpress.com/2012/01/20/software-quality-assurance/feed/ 0 28.643869 77.244294 28.643869 77.244294 Priyanka Batra 9789350042663 http://dreamtechpress.wordpress.com/2012/01/07/exploring-the-xaml-element-tree-in-wpf/ http://dreamtechpress.wordpress.com/2012/01/07/exploring-the-xaml-element-tree-in-wpf/#comments Sat, 07 Jan 2012 11:39:12 +0000 Dreamtech Press http://dreamtechpress.wordpress.com/?p=4239 ]]> Free Excerpt from Chapter 2 of the book WPF 4.0 In Simple Steps by Kogent Learning Solutions Inc.

As you know, you can create both standalone applications and XBAPs with the help of WPF. When you create a WPF application in Visual Studio 2010, the default XAML code provides the default UI of the application. The XAML code is a hierarchy of several XAML elements, which are markup entities that indicate some information about the UI controls. The default XAML code of a WPF application contains two XAML elements— Window and Grid for standalone applications and Page and Grid for XBAPs. The Window element and the Page element are the root elements in standalone applications and XBAPs, respectively. There can be exactly one root element in the XAML code of a WPF application. In addition, the root element, the WPF application can have exactly one child element. By default, the Grid element is the child element of the Window and Page elements in the standalone applications and XBAPs, respectively.

However, in WPF standalone and XBAP applications you can have other child elements by adding controls in the parent elements. When you add controls to a WPF application at design time, each control corresponds to an XAML element. These elements become the child elements of the default Grid element. Depending on the type of the element, these child elements can in turn contain other child elements. For example-The Button control is a child element of the Grid control, which in turn can have Label as a child element. In this way, the entire UI of a WPF application takes the form of a tree-like structure.

In this tree, there is one root node with only one child node. The child node in turn has one or more child nodes. The tree branches out to show the UI of the application as you keep adding controls or XAML elements in a WPF application.

Let’s take an example of a WPF standalone application named MyWPFApplication, which is created using Visual C#. Listing 2.1 shows the XAML code of the application:

Listing 2.1: Showing the XAML Code of the MyWPFApplication Application

<Window x:Class=”MyWPFApplication.MainWindow

   xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”

   xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”

   Title=”MainWindow” Height=”300″ Width=”300″>

   <Grid>

         <Button Margin=”100,25,100,200″ Name=”button1″>Welcome</Button>

         <Button Margin=”100,100,100,125″ Name=”button2″>WPF</Button>

         <Button Margin=”50,150,50,10″ Name=”button3″>

                 <Label Margin=”5,5,5,5″ Name=”label1″>XAML</Label>

         </Button>

   </Grid>

</Window>

In Listing 2.1, there are four XAML elements, namely Window, Grid, Button, and Label. The Window and Grid elements exist in the WPF application by default, while the Button and Label elements are added by dragging and dropping the Button and Label controls from the Toolbox.

Construction is a procedure that involves creating buildings or assembling infrastructures. It requires higher level of supervision and effective planning to handle tasks that result in the successful execution of projects. Construction can be divided into three different areas: building, heavy/civil, and industrial. Each of these areas requires a team to plan, design, and construct the project. AutoCAD 2012 helps in designing the planned requirements in a defined space without constructing them in the physical or real form. Firstly, the entire requirements for the project are decided and then the designers work on these requirements to design the project in AutoCAD 2012.

Building Construction

Building construction is an area of construction where small or big structures are added to the existing real properties. Generally, the building construction projects are small renovations, such as adding a room or refurbishing a bathroom. The owner of a property handles the laborers as well as manages the cost of the entire project. In other words, the owner is responsible for managing economic limits, designing plans, estimating cost, and handling legal deliberations. Moreover, the owners categorized for public or private constructions uses various delivery methodologies, such as hard bod, construction management, construction management at risk, and negotiated price, can do building constructions.  Materials, such as timber, stone, and brick, are widely used in building constructions. Cost of construction is estimated on per square foot basis. This can vary significantly on local sites considering their conditions and economies of scales.

Heavy/Civil Construction

Heavy/civil construction involves creating high-end infrastructures that deal with the environment and building parameters. To construct heavy/civil structures, the private agencies or companies need to get the legal permit for the construction. In addition, they must have the specialization over the required materials and the procedure to construct the heavy structures. Moreover, the selection of materials, such as brick, stone, and timber, available in the construction sites must be supervised by the experts. Heavy/civil construction also considers the cost of construction on the basis of per square meter or per square foot. These cost specifications are based on different conditions, such as location of site, local regulations, economies of scale, and the availability of skilled civil engineers.

Industrial Construction

Apart from having a smaller part in the area of construction, industrial construction plays an important role in constructing structures. The owners of industrial projects are usually large, for-profit, industrial corporations. You can organize these industrial corporations as infrastructure, metallurgical and material handling, medicine, petroleum, chemical, power generation, and manufacturing. The requirements related to the industrial construction highly considered from the expertise in planning,cost estimating, design, and constructing methodologies. You also need a team of individuals like any other construction areas, to ensure a successful project undertaken by big construction companies.

Enabling users to send funds for their orders, one of Lift’s modules provides out-of-the-box support for the online payment service provider PayPal. The integration supports the two most common forms of electronic payment used by PayPal: Payment Data Transfer (PDT)1 and Instant Payment Notification (IPN)2. In order to get access to the integration, simply add the following dependency to your SBT project definition, run the update command and away you go:

val paypal = “net.liftweb” % “lift-paypal” % liftVersion % “compile”

The PayPal integration negates your having to set up your own dispatch functions and other elements necessary for handling the responses from PayPal and parsing their post-back to your application. Typically, all you need to do is create a handler singleton (object) that implements methods required by the PaypalPDT and PaypalIPN traits and hook up the dispatchers supplied by those traits in your application boot.

Environment setup

Before we cover the implementation, however, there are several things you must know about PayPal and their developer process. You will need to register yourself on developer.paypal.com. The first thing you should do before going any further would be to do some background reading on the process of PDT and IPN. The online documentation is very comprehensive and I won’t repeat it here other than to touch on some high-level configuration instructions. With your account created and at developer.paypal.com, follow the steps in table 1—I have placed links to the online PayPal documentation where applicable.

Now that your environment is set up, we need to actually wire up the Lift side of things; otherwise, the communications from PayPal will disappear. As we mentioned earlier, two main traits in the PayPal package take responsibility for the two supported transaction systems—PaypalIPN and PaypalPDT. In this example, let’s create a handler that implements these traits called PaypalHandler with an implementation as shown in listing 1.

Listing 1 The PaypalHandler implementation

import net.liftweb.common.{Loggable,Full,Box,Empty,Failure}
import net.liftweb.paypal.{PaypalIPN,PaypalPDT,
PaypalTransactionStatus,PayPalInfo}
import net.liftweb.http.DoRedirectResponse
import net.liftweb.mapper.By
import example.travel.model.{Order,OrderStatus}
object PaypalHandler extends PaypalIPN with PaypalPDT with Loggable {
val paypalAuthToken = “yourtokengoeshere” 1
def pdtResponse = {
case (info, resp) => info.paymentStatus match {
case Full(PaypalTransactionStatus.CompletedPayment) => 2
DoRedirectResponse.apply(“/paypal/success”) 2
case _ => DoRedirectResponse.apply(“/paypal/failure”) 3
}
}
def actions = {
case (PaypalTransactionStatus.CompletedPayment,info,_) => 4

updateOrder(info,OrderStatus.Complete) 4
case (PaypalTransactionStatus.FailedPayment,info,_) => 4
updateOrder(info,OrderStatus.Failed) 4
case (status, info, resp) => 4
} 4
private def updateOrder(info: PayPalInfo, status: OrderStatus.Value){ 5
Order.find(By(Order.reference, 5
info.itemNumber.map(_.toLong).openOr(0L))) match { 5
case Full(order) => order.status(status).save 5
case _ => 5
} 5
} 5
}
1 PDT token key
2 Successful PDT action
3 Failure PDT action
4 IPN response handlers
5 Find and update order by ref

So, there is a fair bit of code here. In short, the two PayPal traits have simply been composed together and the required methods have been implemented to handle the various responses PayPal might provide. It does, however, go without saying that this is for example only. In a live production system you would account for a lot more responses and intelligently handle them; this, in comparison, is a mere stub to illustrate the process and ease of implementing ecommerce within Lift. (#1) When you enabled PDT within the PayPal sandbox, you would have been assigned a security token to use within the PDT request; enter it here, so PayPal will know that it’s your application calling back to it for information on the transaction. In this implementation, PDT serves only to display the correct response screen back to the user; #2 and #3 dictate the URL to which the user should be redirected based on the result of their transaction. #4 is somewhat more complex since, when the PayPal servers make the IPN call back to the application, it contains much more data and is generally considered the best way to then update the order information with the transaction data and so on. Here, we have a helper method at #5 that will look up an order by its random order reference number that was generated when the order was created; then, depending upon the status received from the IPN data, the order has its status set appropriately.

While this code is functional, it is currently not wired into the application boot cycle, so it won’t ever be called by anything. With two lines of code in your Boot class you can include the functionality:

import net.liftweb.paypal.PaypalRules
import example.travel.lib.PaypalHandler
class Boot extends Loggable {
def boot {
…
PaypalRules.init
PaypalHandler.dispatch.foreach(LiftRules.dispatch.append(_))
…
}
}

These two lines of code first initialize the PaypalRules object that contains configuration information used to determine a range of factors about the transaction. For example, it contains a function configuration that lets you dynamically determine which currency should be used when communicating with PayPal. In this instance, it uses the defaults, so it will just select a currency based on the locale of the JVM running the example. Secondly, it takes the dispatch functions in the PaypalHandler object (inherited, of course, from the two Lift PayPal traits), which respond to the PDT and IPN callbacks, and maps them into the application using Lift’s dispatching mechanism.

The Buy Now button

With the backend all wired up and ready to go, we need to supply the user with a simple one-click icon to instantiate the transaction process in the familiar PayPal way: a bright orange button! Within Lift’s PayPal support there is a mechanism for automatically generating these buttons; you simply need to implement the BuyNowSnippet trait into one of your snippet classes, and populate the required methods so it knows the value and several other aspects of metadata that you wish to send to PayPal.

Listing 2 details the OrderSummary snippet that computes the overall worth of an order and presents the user with a rundown of what they were going to purchase.

Listing 2 The OrderSummary

import scala.xml.{NodeSeq,Text}
import net.liftweb.util.Helpers._
import example.travel.model.Customer
class OrderSummary {
val order = Customer.currentUser.flatMap(_.order)
val amount = order.map(_.totalValue).openOr(0D)
val reference = order.map(_.reference.is.toString).openOr(“n/a”)
def value(xhtml: NodeSeq): NodeSeq = Text(amount.toString) 1
def shipping(xhtml: NodeSeq): NodeSeq = 2
Customer.currentUser.flatMap(_.order.map(order => 2
bind(“s”,xhtml, 2
“address_one” -> order.shippingAddressOne.is, 2
“address_two” -> order.shippingAddressTwo.is, 2
“city” -> order.shippingAddressCity.is, 2
“postcode” -> order.shippingAddressPostalCode.is 2
))).openOr(Text(“Unable to obtain shipping information”)) 2
}

1 Get total order value for auction
2 Bind shipping info from order

There are two key methods here: #1 is obtaining the overall value of the order using the totalValue helper method that was added to the Order model. The second method here (#2) simply reads the values that were entered in the Checkout screen and binds them for display in the usual manner. Had we been using a full Wizard, we would not need to reload the values in the same way but, for the sake of simplicity and as a reiteration of what has already been covered so far, it makes sense to do it this way rather than complicate the example with yet more new content.

Since this already has the data we need for the button, the simplest approach is to just compose the BuyNowSnippet with the existing class. Listing 3 shows the changes made to the class.

Listing 3 Implementing the BuyNowSnippet trait

import net.liftweb.paypal.snippet.BuyNowSnippet
class OrderSummary extends BuyNowSnippet { 1
override def dispatch = { 2
case “paynow” => buynow _ 2
…
}
override val values = Map( 3
“business” -> “me@business.com”, 3
“item_number” -> reference, 3
“item_name” -> (“Auction Order: ” + reference)) 3
}
1 Compose the trait
2 Setup the dispatch
3 Configure the PayPal fields

As you can see in the listing, very few lines of code are required to actually implement the button; the main code is overriding the Map[String,String] of key-value pairs that need to be included in the form submission to PayPal. Finally, ensure you add the PayPal response pages to the SiteMap within the Boot class:

Menu(“Transaction Complete”) / “paypal” / “success”
>> LocGroup(“public”) >> Hidden,
Menu(“Transaction Failure”) / “paypal” / “failure”
>> LocGroup(“public”) >> Hidden,

For simplicity sake, I have just populated these two files with a friendly message so the user is aware of the transaction outcome. You might even want to customize the pages with customer information about their order or such; you have everything at your disposal within the PDT and IPN responses supplied by PayPal.

The advancements in several technologies have played crucial role in the development of low-cost hardware and software components, thereby leading to the increasing demand of computers. Therefore the Cluster Computing has gained momentum in response of these advancements.

Software technologies, such as Operating System (OS), programming languages, development methodologies and tools, have played a vital role in the evolution of new computing era, thereby enabling the development and deployment of scientific, engineering, and commercial applications. Cluster computers also support several mission-critical applications, which are the applications whose failure results in great loss. Example of a mission-critical application is a business information system whose failure leads to inability to perform daily business activities.

A cluster system also makes sure that processors are utilized effectively to maximize the system’s throughput. In a multithreading environment where applications execute, parallelism can be easily achieved, as connected processors work in coordination to execute multiple operational threads at relatively high speed. In sequential computing systems, computing operations are performed sequentially; it means the input of the second operation is dependent on the output of the first operation. Therefore, sequential computing systems are not suitable for large scale and critical applications, as their computing speed is quite slow. However, the technology behind the sequential computing system has evolved over the years to visualize the concept of parallel computing. Several parallel computers use memory, processors, local disks, high-speed switches, and networking technologies to deploy a highly scalable computing environment, wherein computing problems can be solved using highly standardized programming tools. The total cost of developing a parallel computer is quite low, which is considered as one of the major reason for the growth of parallel computing systems.

Lift is a Scala-based web framework designed for extremely interactive and engaging web applications. It’s highly scalable, production-ready, and will run in any servlet container. And Lift’s convention-over-configuration approach lets you avoid needless work.

Lift in Action is a step-by-step exploration of the Lift framework. It moves through the subject quickly using carefully crafted, well-explained examples that make you comfortable from the start. You will follow an entertaining Travel Auction application that covers the core concepts and shows up architectural and development strategies. Handy appendixes offer a Scala crash course and guidance for setting up a good coding environment.

This book is written for developers who are new to both Scala and Lift and covers just enough Scala to get you started.

What’s Inside:

• Complete coverage of the Lift framework
• Security, maintainability, and performance
• Integration and scaling
• Covers Lift 2.x

About the Author:

Timothy Perrett is a member of the Lift core team and a Scala developer specializing in integration and automation systems for both manufacturing and marketing workflows.

ISBN: 978-93-5004-292-2

Pages: 426

Price: Rs. 599/-

What’s Inside:

• An introduction to earth and environment
• Global issues concerning the environment
• Importance of conservation of energy
• An introduction to atmosphere and ecosystem
• Importance and benefits of f biodiversity
• Effects and measures to control air pollution
• Effects and measures to control soil pollution
• Characteristics and effects of noise pollution
• Impact of solid waste on society and environment
• Environmental ethics and morals

About the Author:

The proficient teams at Kogent Learning Solutions Inc. and Dreamtech Press have seized the market of engineering textbooks, bringing excellent content in engineering and technical education to the fore. The teams at Kogent Learning Solutions, Inc. and Dreamtech Press are committed to providing excellence in quality of content by judiciously analyzing the needs of its readers and ensuring dedication of its authors and editors in catering to these needs.

ISBN: 978-93-5004-280-9
Pages: 216
Price: Rs. 249/-

Inside the Book:

• Introduction to AutoCAD 2012
• The process of drafting a basic floor plan
• The process of adding text and dimensions in the floor plan
• The process of working with layers
• The process of drafting a civil architecture in AutoCAD 2012
• The process of drafting a township project in AutoCAD 2012
• The process of working with 3D and design mechanical objects
• Plotting and printing drawings in AutoCAD 2012

About the Author:

The proficient team at Kogent Learning Solutions Inc. and Dreamtech Press has seized the market of computer books bringing excellent content in software development to the fore. The team is committed to excellence—excellence in quality of content; excellence in the dedication of its authors and editors; excellence in the attention to detail; and excellence in understanding the needs of their readers.

ISBN: 978-93-5004-277-9 | Pages: 336 | Price: Rs. 229/-