Sunday, February 21, 2010

Debugging

Finding and fixing bugs, or "debugging", has always been a major part of computer programming. Maurice Wilkes, an early computing pioneer, described his realization in the late 1940s that much of the rest of his life would be spent finding mistakes in his own programs. As computer programs grow more complex, bugs become more common and difficult to fix. Often programmers spend more time and effort finding and fixing bugs than writing new code. Software testers are professionals whose primary task is to find bugs, or write code to support testing. On some projects, more resources can be spent on testing than in developing the program.

Usually, the most difficult part of debugging is finding the bug in the source code. Once it is found, correcting it is usually relatively easy. Programs known as debuggers exist to help programmers locate bugs by executing code line by line, watching variable values, and other features to observe program behavior. Without a debugger, code can be added so that messages or values can be written to a console (for example with printf in the c language) or to a window or log file to trace program execution or show values.

However, even with the aid of a debugger, locating bugs is something of an art. It is not uncommon for a bug in one section of a program to cause failures in a completely different section, thus making it especially difficult to track (for example, an error in a graphics rendering routine causing a file I/O routine to fail), in an apparently unrelated part of the system.

Sometimes, a bug is not an isolated flaw, but represents an error of thinking or planning on the part of the programmer. Such logic errors require a section of the program to be overhauled or rewritten. As a part of Code review, stepping through the code modelling the execution process in one's head or on paper can often find these errors without ever needing to reproduce the bug as such, if it can be shown there is some faulty logic in its implementation.

But more typically, the first step in locating a bug is to reproduce it reliably. Once the bug is reproduced, the programmer can use a debugger or some other tool to monitor the execution of the program in the faulty region, and find the point at which the program went astray.

It is not always easy to reproduce bugs. Some are triggered by inputs to the program which may be difficult for the programmer to re-create. One cause of the Therac-25 radiation machine deaths was a bug (specifically, a race condition) that occurred only when the machine operator very rapidly entered a treatment plan; it took days of practice to become able to do this, so the bug did not manifest in testing or when the manufacturer attempted to duplicate it. Other bugs may disappear when the program is run with a debugger; these are heisenbugs (humorously named after the Heisenberg uncertainty principle.)

Debugging is still a tedious task requiring considerable effort. Since the 1990s, particularly following the Ariane 5 Flight 501 disaster, there has been a renewed interest in the development of effective automated aids to debugging. For instance, methods of static code analysis by abstract interpretation have already made significant achievements, while still remaining much of a work in progress.

As with any creative act, sometimes a flash of inspiration will show a solution, but this is rare and, by definition, cannot be relied on.

There are also classes of bugs that have nothing to do with the code itself. If, for example, one relies on faulty documentation or hardware, the code may be written perfectly properly to what the documentation says, but the bug truly lies in the documentation or hardware, not the code. However, it is common to change the code instead of the other parts of the system, as the cost and time to change it is generally less. Embedded systems frequently have workarounds for hardware bugs, since to make a new version of a ROM is much cheaper than remanufacturing the hardware, especially if they are commodity items.

Software Bug

A software bug is the common term used to describe an error, flaw, mistake, failure, or fault in a computer program or system that produces an incorrect or unexpected result, or causes it to behave in unintended ways. Most bugs arise from mistakes and errors made by people in either a program's source code or its design, and a few are caused by compilers producing incorrect code. A program that contains a large number of bugs, and/or bugs that seriously interfere with its functionality, is said to be buggy. Reports detailing bugs in a program are commonly known as bug reports, fault reports, problem reports, trouble reports, change requests, and so forth.


Prevention

Bugs are a consequence of the nature of human factors in the programming task. They arise from oversights or mutual misunderstandings made by a software team during specification, design, coding, data entry and documentation. For example: In creating a relatively simple program to sort a list of words into alphabetical order, one's design might fail to consider what should happen when a word contains a hyphen. Perhaps, when converting the abstract design into the chosen programming language, one might inadvertently create an off-by-one error and fail to sort the last word in the list. Finally, when typing the resulting program into the computer, one might accidentally type a '<' where a '>' was intended, perhaps resulting in the words being sorted into reverse alphabetical order. More complex bugs can arise from unintended interactions between different parts of a computer program. This frequently occurs because computer programs can be complex — millions of lines long in some cases — often having been programmed by many people over a great length of time, so that programmers are unable to mentally track every possible way in which parts can interact. Another category of bug called a race condition comes about either when a process is running in more than one thread or two or more processes run simultaneously, and the exact order of execution of the critical sequences of code have not been properly synchronized.

The software industry has put much effort into finding methods for preventing programmers from inadvertently introducing bugs while writing software.[11][12] These include:

Programming style
While typos in the program code most likely are caught by the compiler, a bug usually appears when the programmer makes a logic error. Various innovations in programming style and defensive programming are designed to make these bugs less likely, or easier to spot.

Programming techniques
Bugs often create inconsistencies in the internal data of a running program. Programs can be written to check the consistency of their own internal data while running. If an inconsistency is encountered, the program can immediately halt, so that the bug can be located and fixed. Alternatively, the program can simply inform the user, attempt to correct the inconsistency, and continue running.

Development methodologies
There are several schemes for managing programmer activity, so that fewer bugs are produced. Many of these fall under the discipline of software engineering (which addresses software design issues as well). For example, formal program specifications are used to state the exact behavior of programs, so that design bugs can be eliminated. Unfortunately, formal specifications are impractical or impossible for anything but the shortest programs, because of problems of combinatorial explosion and indeterminacy.

Programming language support
Programming languages often include features which help programmers prevent bugs, such as static type systems, restricted name spaces and modular programming, among others. For example, when a programmer writes (pseudocode) LET REAL_VALUE PI = "THREE AND A BIT", although this may be syntactically correct, the code fails a type check. Depending on the language and implementation, this may be caught by the compiler or at runtime. In addition, many recently-invented languages have deliberately excluded features which can easily lead to bugs, at the expense of making code slower than it need be: the general principle being that, because of Moore's law, computers get faster and software engineers get slower; it is almost always better to write simpler, slower code than "clever", inscrutable code, especially considering that maintenance cost is considerable. For example, the Java programming language does not support pointer arithmetic; implementations of some languages such as Pascal and scripting languages often have runtime bounds checking of arrays, at least in a debugging build.

Code analysis
Tools for code analysis help developers by inspecting the program text beyond the compiler's capabilities to spot potential problems. Although in general the problem of finding all programming errors given a specification is not solvable (see halting problem), these tools exploit the fact that human programmers tend to make the same kinds of mistakes when writing software.

Instrumentation
Tools to monitor the performance of the software as it is running, either specifically to find problems such as bottlenecks or to give assurance as to correct working, may be embedded in the code explicitly (perhaps as simple as a statement saying PRINT "I AM HERE"), or provided as tools. It is often a surprise to find where most of the time is taken by a piece of code, and this removal of assumptions might cause the code to be rewritten.

Tuesday, February 16, 2010

Most common problems associated with Computer Software?

Viruses is one of the main problems as well as downloading. When you down load multiple things on to your computer you have the problem of almost filling up the MB also known as Mega Bites. When you will all of your computers memory (MG as we as KB) ( KB stands for Killa Bits a thousand KB makes one MB) the computer gets slower because it has a harder time loading or starting up the programs that you have downloaded. DO NOT and I mean DO NOT go into the folder that lets you deleet floders unles you know what you are doing. If you do not know what you are doing Do NOT try to attempt anything you could deleet something that is very important. Every computer has Memory on it that can not be axied although some of it can. The reason that memory can not be axied is because it is important and if you deleet it you could damage your computer. Another computer problem that is big is software not downloading right or letting in as i said before viruses. A Viruses is a bad thing. A viruses can let things lit hackers or bugs that take over your computer or that deleet memory as well as folders. When your computer gets hacked nothing on it id personal anymore. The hacker has all of your files all of your pictures. They can tell what time you got on the internet.

Sunday, February 7, 2010

Software as a service

Software as a service (SaaS, typically pronounced 'sass') is a model of software deployment whereby a provider licenses an application to customers for use as a service on demand. SaaS software vendors may host the application on their own web servers or upload the application to the consumer device, disabling it after use or after the on-demand contract expires. The on-demand function may be handled internally to share licenses within a firm or by a third-party application service provider (ASP) sharing licenses between firms

History

The concept of "software as a service" started to circulate before 1999.[1] In December 2000, Bennett et al. noted the term as "beginning to gain acceptance in the marketplace".[2]

While the phrase "software as a service" passed into common usage, the CamelCase acronym "SaaS" term was coined by Bennett et al as the “beginning for gaining acceptance in the marketplace” in December 2000. An article called "Strategic Backgrounder: Software as a Service", published in February 2001 by the Software & Information Industry's (SIIA) eBusiness Division, discusses this. The claim that it was actually written in the fall of 2000 angers Bennett (according to internal Association records).[3]

One of the first SaaS applications was SiteEasy, a web-site-in-a-box for small businesses, that launched in 1998 at Siteeasy.com. Developed by Atlanta-based firm WebTransit (co-founded by Gary Troutman and Drew Wilkins), SiteEasy was sold on a subscription-basis for a monthly fee to its first customer in the Fall of 1998.


Philosophy

As a term, SaaS is generally associated by software professionals and business associates with business software and is typically thought of as a low-cost way for businesses to obtain rights to use software as needed versus licensing all devices with all applications. On-demand licensing enables the benefits of commercially licensed use without the associated complexity and potential high initial cost of equipping every device with the applications that are only used when needed.

Virtually all software fits the SaaS model well.[citation needed] Many Unix applications already have this functionality whereas EULA applications never had this flexibility before SaaS.[clarification needed] A licensed copy of a word processor, for example, had to reside on the machine to create a document. The equipped program has no intrinsic value loaded on a computer that is turned off for the night. Worse yet, the same employee may need another fully paid license to write or edit a report at home on their own computer, while the work license is inoperative. Remote administration software attempts to resolve this issue through sharing CPU controls instead of licensing on demand. While promising, it requires leaving the licensed host computer on and it creates security issues from the remote accessing to run an application. SaaS achieves efficiencies by enabling the on demand licensing and management of the information and output, independent of the hardware location.

SaaS applications differ from earlier applications delivered over the Internet in that SaaS solutions were developed specifically to leverage web technologies such as the browser, thereby making them web-native.[citation needed] The data design and architecture of SaaS applications are specifically built with a 'multi-tenant' backend, thus enabling multiple customers or users to access a shared data model. This further differentiates SaaS from client/server or 'ASP' (Application Service Provider) solutions in that SaaS providers leverage enormous economies of scale in deployment, management, and support throughout the Software Development Lifecycle.



Key characteristics


Characteristics of SaaS include:[5][dead link]

* network-based access to, and management of, commercially available software
* activities managed from central locations rather than at each customer's site, enabling customers to access applications remotely via the Web
* application delivery typically closer to a one-to-many model (single instance, multi-tenant architecture) than to a one-to-one model, including architecture, pricing, partnering, and management characteristics
* centralized feature updating, which obviates the need for end-users to download patches and upgrades.
* frequent integration into a larger network of communicating software - either as part of a mashup or as a plugin to a platform as a service. (Service oriented architecture is naturally more complex than traditional models of software deployment.) Related Resources:
.NET Development Services: Xicom is an offshore ASP.NET development company, offering custom .NET web application development services, .NET software development services and affordable .NET development outsourcing services based in india
Outsource php Development: Classic Informatics is a global web development and mobile apps development company Outsource php Development, iPhone Apps Programming, Android Apps Development, Facebook Apps Development, Custom Web Development, ASP .Net Development, eCommerce Websites, CMS Websites and more.
Best IT Companies : SapientIndiaCareer provide you best job in IT Companies, you find the perfect jobs in IT/Software field in the India’s leading Software Companies at SapientIndiaCareers.com, upload your CV to apply now.
search engine optimization Denver : Green Vine Marketing offers a perfect user interface for ensuring web presence of a company. The services are excellent and are offered at affordable rates.
Breckenridge Real Estate | East Bay Homes For Sale | Naples Home For Sale | www.power-backlinks.de| Fuse Wave | Bethesda Real Estate| Bel Air real estate| Cape May NJ Realtor| mid century homes for sale| home inspection phoenix| Tarvin Realtors| Punta del Este Real Estate| horseshoe bay real estate | Ocean City NJ rentals| North Carolina Homes Foreclosed| copywriting services

Friday, February 5, 2010

Agile Software Development

There are many specific agile development methods. Most promote development , teamwork, collaboration, and process adaptability throughout the life-cycle of the project.

Agile methods break tasks into small increments with minimal planning, and do not directly involve long-term planning. Iterations are short time frames ("timeboxes") that typically last from one to four weeks. Each iteration involves a team working through a full software development cycle including planning, requirements analysis, design, coding, unit testing, and acceptance testing when a working product is demonstrated to stakeholders. This helps minimize overall risk, and lets the project adapt to changes quickly. Stakeholders produce documentation as required. An iteration may not add enough functionality to warrant a market release, but the goal is to have an available release (with minimal bugs) at the end of each iteration.[1] Multiple iterations may be required to release a product or new features.

Team composition in an agile project is usually cross-functional and self-organizing without consideration for any existing corporate hierarchy or the corporate roles of team members. Team members normally take responsibility for tasks that deliver the functionality an iteration requires. They decide individually how to meet an iteration's requirements.

Agile methods emphasize face-to-face communication over written documents when the team is all in the same location. When a team works in different locations, they maintain daily contact through videoconferencing, voice, e-mail, etc.

Most agile teams work in a single open office (called bullpen), which facilitates such communication. Team size is typically small (5-9 people) to help make team communication and team collaboration easier. Larger development efforts may be delivered by multiple teams working toward a common goal or different parts of an effort. This may also require a coordination of priorities across teams.

No matter what development disciplines are required, each agile team will contain a customer representative. This person is appointed by stakeholders to act on their behalf and makes a personal commitment to being available for developers to answer mid-iteration problem-domain questions. At the end of each iteration, stakeholders and the customer representative review progress and re-evaluate priorities with a view to optimizing the return on investment and ensuring alignment with customer needs and company goals.

Most agile implementations use a routine and formal daily face-to-face communication among team members. This specifically includes the customer representative and any interested stakeholders as observers. In a brief session, team members report to each other what they did yesterday, what they intend to do today, and what their roadblocks are. This standing face-to-face communication prevents problems being hidden.

Agile emphasizes working software as the primary measure of progress. This, combined with the preference for face-to-face communication, produces less written documentation than other methods—though, in an agile project, documentation and other artifacts rank equally with a working product. The agile method encourages stakeholders to prioritize wants with other iteration outcomes based exclusively on business value perceived at the beginning of the iteration.

Specific tools and techniques such as continuous integration, automated or xUnit test, pair programming, test driven development, design patterns, domain-driven design, code refactoring and other techniques are often used to improve quality and enhance project agility.