• Schedule slips—the day for delivery comes, and you have to tell the customer that the software won't be ready for another six months.
  

• Project canceled—after numerous slips, the project is canceled without ever going intoproduction.
  

• System goes sour—the software is successfully put into production, but after a couple of years the cost of making changes or the defect rate rises so  much that the system must bereplaced.
  

• Defect rate—the software is put into production, but the defect rate is so high that it isn't used.
  

• Business misunderstood—the software is put into production, but it doesn't solve the business problem that was originally posed.
  

• Business changes—the software is put into production, but the business problem it was designed to solve was replaced six months ago by another, more pressing, business problem.
  

• False feature rich—the software has a host of potentially interesting features, all of whichwere fun to program, but none of which makes the customer much money.
  

• Staff turnover—after two years, all the good programmers on the project begin to hate the program and leave.

• Its early, concrete, and continuing feedback from short cycles

• Its incremental planning approach, which quickly comes up with an overall plan that is expected to evolve through the life of the project.
  

• Its ability to flexibly schedule the implementation of functionality, responding to changing business needs.
  

• Its reliance on automated tests written by programmers and customers to monitor the progress of development, to allow the system to evolve, and to catch defects early.
  

• Its reliance on oral communication, tests, and source code to communicate system structure and intent.
  

• Its reliance on an evolutionary design process that lasts as long as the system lasts.

• Its reliance on the close collaboration of programmers with ordinary skills.

• Its reliance on practices that work with both the short-term instincts of programmers and the long-term interests of the project.

From Wikipedia, the free encyclopedia

The Common Object Request Broker Architecture (CORBA) is a standard defined by the Object Management Group (OMG) that enables software components written in multiple computer languages and running on multiple computers to work together.

• JavaScript that allows for interaction with the browser and responding to events
• The DOM for accessing and manipulating the structure of the HTML of the page
• XML, which represents the data passed between the server and client.
• An XMLHttpRequest object for asynchronously exchanging the XML data between the client and the server.

A message-driven bean is an enterprise bean that allows Java EE applications to process messages asynchronously. It normally acts as a JMS message  listener, which is similar to an event listener except that it receives JMS messages instead of events. The messages can be sent by any Java EE component—an application client, another enterprise bean, or a web component—or by a JMS application or system that does not use Java EE technology. Message-driven beans can process JMS messages or other kinds of messages.

What Makes Message-Driven Beans Different from Session Beans?

The most visible difference between message-driven beans and session beans is that clients do not access message-driven beans through interfaces. 

Acceptance testing generally involves running a suite of tests on the completed system. Each individual test, known as a case, exercises a particular operating condition of the user's environment or feature of the system, and will result in a pass or fail boolean outcome. There is generally no degree of success or failure. The test environment is usually designed to be identical, or as close as possible, to the anticipated user's environment, including extremes of such. These test cases must each be accompanied by test case input data or a formal description of the operational activities (or both) to be performed—intended to thoroughly exercise the specific case—and a formal description of the expected results.

Hibernate is a powerful, high performance object/relational persistence and query service. Hibernate lets you develop persistent classes following object-oriented idiom - including association, inheritance, polymorphism, composition, and collections. Hibernate allows you to express queries in its own portable SQL extension (HQL), as well as in native SQL, or with an object-oriented Criteria and Example API.

Before we can use log4j in an application, we need to configure log4j in an application-specific manner. Configuring log4j typically involves assigning Level, defining Appender, and specifying Layout objects. The configuration information is conventionally defined within a properties file in a key-value pattern. It is also possible to define the log4j configuration in an XML format, which we will discuss later in this section. By default, the LogManager class will look for a file named "log4j.properties" in the classpath used for loading the log4j classes.

The architecture of the log4j API is layered. Each layer consists of different objects performing different tasks. The top layer captures the logging information, the middle layer is involved in analyzing and authorizing the logging information, and the bottom layer is responsible for formatting and publishing the logging information to a destination. In essence, log4j consists of three types of primary objects:

• Logger: The Logger object (formerly known as the Category object in releases prior to log4j 1.2) is responsible for capturing logging information. Logger objects are stored in a namespace hierarchy.
  

• Appender: The Appender object is responsible for publishing logging information to various preferred destinations. Each Appender object will have at least one target destination attached to it. For example, a ConsoleAppender object is capable of printing logging information to a console.
  

• Layout: The Layout object is used to format logging information in different styles. Appender objects utilize Layout objects before publishing logging information. Layout objects play an important role in publishing logging information in a way that is human readable and reusable.
  

 UDP dominira nad TCP-om kod aplikacija koje se izvršavaju u realnom vremenu. UDP se koristi iz više razloga:

• Bolja kontrola na nivou aplikacije nad sadržajem i vremenom slanja. Ako se koristi UDP, čim aplikacijski proces preda podatke UDP-u, UDP će spakovati podatke u UDP segment i odmah predati segment mrežnom sloju. Pošto aplikacije u realnom vremenu zahtevaju garantovanu frekvenciju slanja i ne žele preterano da odlažu prenošenje segmenata, a mogu da tolerišu mali gubitak podataka, model TCP usluge nije naročito pogodan za potrebe takvih aplikacija.
• Nema uspostavljanja konekcije. Kod UDP-a, za raliku od TCP-a, nema sinhronizacije u tri koraka i prema tome nema ni kašnjena prilikom uspostavljanja konekcije.
• Nema stanja konekcije. UDP ne zahteva privremenu memoriju za slanje i primanje, parametre za kontrolu zagušenja i parametre za redne brojeve i brojeve potvrda. Zato server namenjen aplikaciji može da podrži veći broj aktivnih klijenata ukoliko se koristi UDP.
• Manje dodatno opterećenje zagčavljem paketa. TCP segment ima zaglavlje od 20 bajtova, dok UDP ima samo 8.

This document describes how to create a simple distributed web application that connects to a MySQL database.
It also covers some basic ideas and technologies in web development, such as Java Server Pages and three-tier architecture which we'll take a closer look at while structuring our web application.
This tutorial is designed for beginners who have a basic understanding of Java programming and web development, and are looking for a more hands-on approach to apply their knowledge.