What are the major goals of Software engineering?

Answer 1

1. Assist with design, analysis, maintenance, documentation, and testing of software. 2. Code, debug, test, and document routine application programs. 3. Install and test routine software packages. 4. Assist users with procedural or minor technical problems. 5. Advise or train users regarding the technical aspects and use of standard software packages. 6. Assist in maintaining program libraries, users' manuals, or technical documentation. 1. Design new systems or enhancements to existing systems. 2. Determine source data (input), processing requirements (output), output formats, timing and cost estimates. 3. Verify that system meets performance criteria. 4. Design, implement, and document procedures. 5. Design/modify, code, debug, test, and document moderately complex application systems. 6. Install and test moderately complex software packages. 7. Install and maintain operating systems software in a small computing center or assist in installing and maintaining operating systems software in a medium to large computing center, e.g., operating systems, data base software, data communication/network software, and utility software. 8. Develop and/or teach seminars, workshops, or classes to users or other Programmer/Analysts on the technical aspects or use of computer hardware, software packages or application systems. 9. Consult on the use of moderately complex software packages. 10. Advise users regarding program techniques and design. 11. Maintain program libraries, users' manuals, or technical documentation. Participation through all aspects of the software development life cycle Design, development, review, and implementation of new applications

Answer 2

The following is written by and according to the U.S. Department of Labor and particular to the nature of work for computer software engineers.

Computer software engineers apply the principles of computer science and mathematical analysis to the design, development, testing, and evaluation of the software and systems that make computers work. The tasks performed by these workers evolve quickly, reflecting new areas of specialization or changes in technology, as well as the preferences and practices of employers.

Software engineers can be involved in the design and development of many types of software, including computer games, word processing and business applications, operating systems and network distribution, and compilers, which convert programs to machine language for execution on a computer.
Computer software engineers begin by analyzing users' needs, and then design, test, and develop software to meet those needs. During this process they create the detailed sets of instructions, called algorithms, that tell the computer what to do. They also may be responsible for converting these instructions into a computer language, a process called programming or coding, but this usually is the responsibility of computer programmers. Computer software engineers must be experts in operating systems and middleware to ensure that the underlying systems will work properly.
Computer applications software engineers analyze users' needs and design, construct, and maintain general computer applications software or specialized utility programs. These workers use different programming languages, depending on the purpose of the program. The programming languages most often used are C, C++, and Java, with Fortran and COBOL used less commonly. Some software engineers develop both packaged systems and systems software or create customized applications.
Computer systems software engineers coordinate the construction, maintenance, and expansion of an organization's computer systems. Working with the organization, they coordinate each department's computer needs-ordering, inventory, billing, and payroll recordkeeping, for example-and make suggestions about its technical direction. They also might set up the organization's intranets-networks that link computers within the organization and ease communication among various departments.
Systems software engineers also work for companies that configure, implement, and install the computer systems of other organizations. These workers may be members of the marketing or sales staff, serving as the primary technical resource for sales workers. They also may help with sales and provide customers with technical support. Since the selling of complex computer systems often requires substantial customization to meet the needs of the purchaser, software engineers help to identify and explain needed changes. In addition, systems software engineers are responsible for ensuring security across the systems they are configuring.
Computer software engineers often work as part of a team that designs new hardware, software, and systems. A core team may comprise engineering, marketing, manufacturing, and design people, who work together to release a product.

Work environment. Computer software engineers normally work in clean, comfortable offices or in laboratories in which computer equipment is located. Software engineers who work for software vendors and consulting firms frequently travel overnight to meet with customers. Telecommuting is also becoming more common, allowing workers to do their jobs from remote locations.
Most software engineers work at least 40 hours a week, but about 17 percent work more than 50 hours a week. Software engineers also may have to work evenings or weekends to meet deadlines or solve unexpected technical problems.
Like other workers who spend long hours typing at a computer, software engineers are susceptible to eyestrain, back discomfort, and hand and wrist problems such as carpal tunnel syndrome.

For the source and more detailed information concerning your request, click on the related links section (U.S. Department of Labor) indicated directly below this answer section.

Answer 3

1. All programming projects should begin with functional descriptions which become the highest level pseudocode. Every module and every routine, high or low level, should have a functional description approptiate to its level of abstraction.
2. Functional descriptions determine high level pseudocode should be iteratively refined to low level pseudocode. The pseudocode becomes internal documentation.
3. Pseudocode should be organized into modules, thus ultimately organizing the project into modules.
4. Computer code for all routines and main programs should be generated from low level pseudocode. The pseudocode should become internal documentation.
5. Module interface specifications should be created so that modules may be created independently.
6. Programs should be constructed from modules.
7. All support routines should reside in separately compiled modules.
8. Each module should only contain routines whose functions are related.
9. Inter-module communication should be accomplished solely through passing parameters. No global variables should be used. Parameters should be passed "by value" where required access is read-only.
10. Communication between routines in the same module should also only be accomplished through parameter passing.
11. Low level routines should have simple and explicit functions. For example low level routines should not do any I/O (especially interaction with the user) unless that is the sole function of that routine.
12. Support routines should be evaluated with respect to flexibility and efficiency.
13. Include files should be used where required to effect inter-module independence and consistency. For example data-type definitions should be included to attain consistent definitions global to all modules.
14. Changes (such as changes to underlying data structures) in low level routines should not require source code changes in high level routines. This is accomplished by carefully constructing the calling interface to adhere to data abstraction principles.
15. Changes (such as changes to the driving application) in high level routines should not require source code changes in low level routines. This is accomplished by carefully constructing the calling interface to adhere to data abstraction principles.
16. Changes to high level routines should not require low level routines to be recompiled.