Hi am anita i would like to get details on solutions of fundamentals of software engineering book by rajib mall .

Fundamentals of Software Development
Software development involves the key task of turning the vision of a software architect into working application code that generates the required result, works under the predefined conditions, is robust and secure, performs within the specified parameters, and achieves all this with optimum efficiency and use of available resources. It may sound a daunting task, but modern software design techniques, tools, development environments, and methodologies allow teams creating software to approach the task in a logical and ordered way so as to maximize the success rate and minimize wasted effort.

The Skills in Development

Whilst a poor initial design will generally fail to translate into good software, there are many tools and techniques available to architects, designers, and developers that can considerably increase the chance of a successful design producing great software. Developers must follow the design specifications, but part of the skill of the job is to be able to visualize how working systems and components interact, understand the limitations applied by the hardware and infrastructure on which the applications will run, and make educated judgments on the trade-offs that are required.

This means that simply knowing how to use a programming language such as C# or Visual Basic is not sufficient. Modern programming frameworks and languages provide virtualized interfaces that hide a great deal of the underlying complexity of the runtime hardware. However, developers must still understand how code executes, how different programming instructions may interact with the underlying infrastructure, and how to implement communication between components that must work with each other­ - often when located remotely and accessed over a network such as the Internet).

Good software design attempts to maximize a range of important factors such as security, usability, testability, maintainability, performance, and more. Developers must understand how their implementations of the design may have an impact on these factors, and be prepared to work with the architect or software designer when it comes to achieving the appropriate trade-offs for each of these factors.

Programming Languages

There are a wide range of languages to choose from when writing software. Some are specific to particular types of applications, while others are used across most types of applications. When working on your own, you may often use the language with which they are most familiar for a range of types of applications. When working in a team, the choice of language is generally specified by project managers.

However, some applications may require the use of more than one programming language or technology. An example is web development, where the code that executes on the web server to create the pages may use ASP.NET Web Forms or WebMatrix Web Pages, the pages themselves may contain JavaScript code that executes in the user's browser to provide interactivity, and the back end code that interacts with the database may be written in a .NET Framework language such as C# or Visual Basic.

This means that you often need to be fluent in several languages. This is not generally difficult as most languages use a similar approach to defining source code instructions, and vary mainly in their syntax; although each language will have specific nuances with which you must become familiar. Typically, however, once you understand the fundamentals of programming and learn one language, it becomes very much easier to learn others.

The vast majority of applications today are written using object-oriented and event-driven programming languages. These types of programming languages use code instructions and constructs such as loops and decision statements to execute a series of tasks. They contain procedures and functions that are called from the main code, often repeatedly from many places in the code. Objects are defined within the code to represent real-world items such as customers, orders, and accounts that the code must manipulate.

These objects have properties that expose the data they contain, and methods that can be executed to manipulate the data. Objects raise events when some action occurs, and the code handles these events as required. Typical object-oriented and event-driven programming languages used on the Microsoft platform are C#, Visual Basic, C++, F#, and JavaScript.

Frameworks, Code Libraries, and Patterns

One of the key factors in simplifying the task of developing the increasingly complex applications required today is the use of frameworks, code libraries, and patterns. Most people dislike rewriting the same code over and over again (it’s repetitive, and wastes time and effort), and prefer to concentrate on the parts of the development process that are directly relevant to the requirements of the application they are building. One way to do this, which can minimize the time, cost, and effort required, is to re-use existing code that performs specific predefined tasks.

Re-usable code comes in many forms. Development teams often create libraries of functions and procedures that they use in more than one component and more than one application. Typical examples are features to implement logging, handle exceptions, cache data, and access databases. It is also possible to obtain or purchase frameworks and code libraries that perform these and a wide range of other tasks. Re-using code that has already been tested and proven to work reliably can considerably reduce the effort required when building software; the skill of the developer is in knowing which frameworks are suitable, and when and how to apply them successfully.

When no re-usable and prebuilt framework or library is available, the development team must write the required code. The development teammust also write the "glue" code that links components together, and calls functions in frameworks and code libraries. This is where an intimate knowledge of programming languages is required. However, there is an additional way that you can benefit from the work of others, even when there is no physical code available. This is the application of software patterns.

Patterns are a concept designed to formalize the knowledge and experience obtained over time when solving common problems in software development. Scenarios that require a code solution have often been tackled many times by others, and an optimal solution has evolved based on the reviews and experience of experts in the field. These scenarios are documented as software design patterns, and include generic definitions of the solution that are not specific to any one code language. However, they offer proven techniques for solving the problem, and the developer's task then is to be aware of relevant patterns, and write code specific to their application but based on the generic solution described by the pattern. This can help to minimize errors and avoid common mistakes encountered in each scenario.

Programming Techniques and Methodologies

Even very experienced people make mistakes when writing code. Complex applications contain many variables, and code that seems to be correct may perform in an unexpected way under some conditions that were not obvious when writing the code. Over time, techniques and methodologies that help to minimize errors have evolved and become formalized. You should be familiar with these techniques and methodologies, even when working alone rather than as part of a team.

One of the major methodologies used today is Test Driven Design (TDD). This methodology aims to make the developer think about the requirements of the code and formulate the required results before writing the actual code. The process involves creating a series of unit tests, each of which exercises a specific function of the design for the section of code being created. For example, if the code will apply a deposit to a customer's account, the test would take the amount of the deposit and the current account balance, pass these to the function in the code the being created, and then assert that the result is correct by checking the account balance.

Unit tests are written first, and following that, code is created that implements the functions required in the application. This code can then be verified by using a test framework (or test harness) to run all of the unit tests and display the results of all the assertions. As you write the code and continuously modify and improve it, the tests can be re-run to ensure that the results are still valid.

Of course, the unit tests cannot operate on the real data, and may not have access to other parts of the application still under construction. Instead, the developer creates mock components that represent the real thing, but run locally on the development machine. This ensures that the tests exercise only the code being created, and the results are not affected by other external factors.

TDD is often combined with other programming methodologies. For example, Pair Programming is commonly used to validate code and minimize errors. Two developers work alongside on one computer, taking it in turns to write code and run the unit tests. The developers work together sharing and combining experience and knowledge, and critiquing the code the other developer is writing. The additional input and competition between the developers can result in better code.

Testing, Staging, and Deployment

The code created during development is often only a section of the overall application or system, and must be integrated with the complete application or system at regular intervals to ensure that there are no issues with interaction between each component or each section of code. A typical approach is to check in code at regular intervals, at which point a complete build of the application or system is initiated. This will reveal any conflicts during compilation and testing, which must get resolved before the next integrated build.

Once the complete application is built and has passed the test cycle, it can be moved to a staging server or computer for final acceptance testing. Unlike the development computer and build servers, the staging server is a replica of the final runtime environment, and this allows the software to be tested under the conditions it will encounter when in production. Again, the development team must resolve any issues arising during the staged acceptance testing cycle.

Applications will usually require some type of installation or setup program that allows them to be deployed on both the staging and final production systems. The development team must create the required setup programs that install the components of the application, configure them and the runtime environment, and prepare the system as required. This is often a complex issue, especially for shrink-wrapped software that may be installed on a variety of runtime platforms with a wide range of underlying hardware other applications present.

Working in a Project Team

Working within a project team can be very rewarding, but requires additional skills to obtain the best results. When working in a team, developers must be able to communicate and interact well with a variety of other people. This includes management, architects and designers, test teams, documentation teams, and many others.

Different styles of project management require developers to apply different capabilities. Some projects are run on traditional "waterfall" lines where each task is compartmentalized and completed before the next task starts. Increasingly, however, projects are run on a more interactive basis. This has proved to offer advantages in many scenarios of application development.

For example, a project may operate using the Agile methodology, where short development iterations, daily stand-up meetings, and weekly review and iteration planning meetings are used to keep the project on track. Agile development emphasizes the customer and external stakeholders' input through regular releases of the software during development, and continual feedback. Typically a repository containing work items is used to keep track of the project, but there is no major up-front design other than that required to get the project under way.

Another common approach is Extreme Programming (XP), in which the development of software is driven by implementation of the most important requirements first, continual communication and testing, and regular delivery of the software during development. Both Agile and XP emphasize the creation of working software over up-front design, and focus on achieving results that match expectations rather than the development of unnecessary features. This means that team members must be productive and work in an efficient, managed, and controlled way to complete the weekly tasks; and to communicate well with all of the other parties involved in the process.

Inter-personal communication is key in modern software development teams, and is easiest and usually most productive when the team works together in the same building; even in the same team room. However, geographically separated teams have been shown to work well as long as individuals manage communication with other team members well. Meetings are held using phone and video conferencing software, the information repository is available over the Internet, and the team members follow strict schedules for daily and weekly meetings. This requires individuals to adjust to time zone restrictions, and interact efficiently with team members of different nationalities, as well as using the communication systems in a way that makes it easy for all members of the team to play a full part.

Learning and Experience

There are few other industries where the technologies, practices, and working environments change as fast as they do in the IT world. Major construction and mechanical engineering projects often run for years, whereas even very large software applications may have a total design-development-deployment lifetime that spans less than one year; and often considerably less. At the same time, the tools, frameworks, infrastructure, and technologies available change very quickly, sometimes on a yearly basis.

This means that the developer must be prepared to spend time keeping up with the changes by learning about new techniques, programming languages, and other technological advances. It also means understanding the trends in the changing IT world, considering how these will affect software being developed today, and being able to adapt their own programming abilities to maximize the use of these new capabilities.

Of all of the skills of the developer, the one that has the most impact on success is experience, and this can only be obtained over time. Working as part of a team, interacting with other developers, and keeping your skills up to date are fundamental requirements. Combining this with a flair for logical thought, creative ability, and a passion for perfection make up the ideal skill set for a software developer.