Skip to main content
Fachgebiete
Automobil + Motoren Bauwesen + Immobilien Business IT + Informatik Elektrotechnik + Elektronik Energie + Nachhaltigkeit Finance + Banking Management + Führung Marketing + Vertrieb Maschinenbau + Werkstoffe Versicherung + Risiko
DE
EN
Bücher
Zeitschriften
Themenseiten
Organisationspsychologie Projektmanagement Marketing Smart Manufacturing
Weitere Formate
Podcasts Webinare Technik Webinare Wirtschaft Kongresse Veranstaltungskalender Awards
Jetzt Einzelzugang starten
Zugang für Unternehmen
Referenzkunden
SLX-Digitalkonferenz: Zukunftswerkstatt 2024

Mehr Umsatz mit Top-Kontakten

Am 7. Mai erfahren Sie, wie Vertriebsteams Leadgenerierung, Leadnurturing und Leadstrategien effizient steuern können.
Erweiterte Suche
Anmelden
nach oben

2015 | Buch

How Enterprise Software Is Different Kapitel lesen Erstes Kapitel lesen

Practical Enterprise Software Development Techniques

Tools and Techniques for Large Scale Solutions

verfasst von: Edward Crookshanks

Verlag: Apress

Enthalten in: Springer Professional "Wirtschaft+Technik" , Springer Professional "Technik" , Springer Professional "Wirtschaft"

Einloggen, um Zugang zu erhalten
insite
SUCHEN

Über dieses Buch

This expanded and updated edition of "Practical Enterprise Software Development Techniques" includes a new chapter which explains what makes enterprise scale software development different from other development endeavors. Chapter 4 has been expanded with additional coverage of code review, bug tracker systems and agile software applications. The chapter order has been changed in response to feedback from readers and instructors who have taught classes using the previous version (which was also published by Apress).

This book provides an overview of tools and techniques used in enterprise software development, many of which are not taught in academic programs or learned on the job. This is an ideal resource containing lots of practical information and code examples that you need to master as a member of an enterprise development team.

This book aggregates many of these "on the job" tools and techniques into a concise format and presents them as both discussion topics and with code examples. The reader will not only get an overview of these tools and techniques, but also several discussions concerning operational aspects of enterprise software development and how it differs from smaller development efforts.

For example, in the chapter on Design Patterns and Architecture, the author describes the basics of design patterns but only highlights those that are more important in enterprise applications due to separation of duties, enterprise security, etc.

The architecture discussion revolves has a similar emphasis – different teams may manage different aspects of the application’s components with little or no access to the developer.

This aspect of restricted access is also mentioned in the section on logging.

Theory of logging and discussions of what to log are briefly mentioned, the configuration of the logging tools is demonstrated along with a discussion of why it’s very important in an enterprise environment.

Inhaltsverzeichnis

Frontmatter
Chapter 1. How Enterprise Software Is Different
Abstract
Computer Science, software engineering, and software development are similar terms that are often used interchangeably. Likewise, there are many different types of educational opportunities available – Bachelor’s programs, associate programs, trade schools, and high-intensity immersion programs. The intent of each of these is to educate the student in varying degrees of theory and turn out an individual capable of understanding and writing software.
Edward Crookshanks
Chapter 2. Software Requirements
Abstract
Writing good requirements is difficult. Interpreting bad requirements is even tougher. But almost all projects start with them and thus they are extremely important. In this chapter, we will define requirements from a couple of different perspectives, discuss how the different perspectives work together, and list some general recommendations about each. We will also cover the roles the developers play in the requirements process and why developing and interpreting requirements are important skills. As with many of the topics in this book, there are countless permutations of the concepts that we are trying to cover and other works that are dedicated solely to the topic of requirements. Here we present a general overview with an emphasis on aspects that are important to developers from an enterprise or large organization perspective.
Edward Crookshanks
Chapter 3. Design Patterns and Architechture
Abstract
The term “Design Pattern” in software engineering refers to a known arrangement of software components that solves a particular problem. These structures provide both a known terminology and known implementation such that once the particular problem is identified, the known structure can be applied. One of the earliest formal definitions of software patterns is detailed in Design Patterns: Elements of Reusable Object-Oriented Software (Gamma et al., 1994), sometimes referred to as the “Gang of Four” (GoF) because of the four original authors. That work has been the inspiration for several updated and language-specific books. In this chapter, we will briefly cover a few GoF patterns to demonstrate the terminology as an introduction to thinking in patterns. We will then talk about some of the more prevalent patterns in use today in the highly distributed world. Finally, we will cover some architectural patterns that are common in large distributed systems and hardware farms that are built for performance and resiliency.
Edward Crookshanks
Chapter 4. Development Methodologies and SDLC
Abstract
Most software development organizations make use of a standard set of practices when developing software. This is commonly known as the software development life cycle (SDLC) and the method used to implement the life cycle falls loosely into two categories: Waterfall and Agile. We will briefly discuss each of these methods but acknowledge that there are many different variations and combinations of techniques. We cannot cover all the variations, but we hope to cover the main points of each such that the variations are simple modifications of what is here, not a radical first step into the world of applied methodologies.
Edward Crookshanks
Chapter 5. Version Control
Abstract
Version control, sometimes referred to as the code or source repository, can serve several purposes in a typical software development organization:
Edward Crookshanks
Chapter 6. Unit Testing and Test-Driven Development
Abstract
Unit testing refers to being able to repeatedly and reliably test a piece of software—a “unit” —for proper functionality. These tests occur at the developer level to ensure that code written for some desired functionality behaves as expected. By ensuring that each “unit” passes the test(s) that it was designed for, the developer can ensure that as the code is integrated into larger and more complex systems each piece of software remains valid.
Edward Crookshanks
Chapter 7. Refactoring
Abstract
The single most important reference on software refactoring is the book “Refactoring: Improving the Design of Existing Code” by Martin Fowler, et al. (1999). There have been many excellent publications since then, but Fowler’s book was one of the first to define the entire process and is the most often referenced. We cannot replicate the entire work here, nor should we attempt to take anything away from it; we will simply start with some realistic code in need of some help, demonstrate the power of refactoring, discuss the merits of the process, and demonstrate how modern tools can help.
Edward Crookshanks
Chapter 8. Debugging
Abstract
Debugging is a very important part of software development. Only developers who never make mistakes or developers who maintain code that have no mistakes should skip this chapter. For the rest of us, use of a debugger is critical to understanding code that isn’t working correctly. We won’t get into the details of “what is a bug,” as this can mean many things to many people. In this chapter, we will simply talk about using the standard IDE tools for examining code. There are many books dedicated to the theory of bugs and debugging; some of these are listed in the additional resources in appendix D.
Edward Crookshanks
Chapter 9. Build Tools and Continuous Integration
Abstract
When compiling a standalone application as part of a programming assignment, or even with a team of other students for a senior project, compilation is usually done manually from within the Integrated Development Environment (IDE). Both Microsoft Visual Studio and Eclipse have menu options and shortcut keys for compiling an application. Often, if a piece of software has dependent components such as external assemblies or JAR files, these are manually copied from a shared directory or some other library sharing mechanism.
Edward Crookshanks
Chapter 10. Just Enough SQL
Abstract
Structured Query Language (SQL) was once thought of just for database administrators (DBAs) or dedicated database developers. In many organizations however, the DBA’s main purpose is support of production systems, and database development is left to the application team.
Edward Crookshanks
Appendix A. Enterprise Considerations and Other Topics
Abstract
There are several factors that differ in an enterprise environment from an educational environment. Depending on the size and structure of the university or college, some of these factors may be experienced to some degree. We will briefly list these concerns from a large organizational perspective and how each impacts or influences software development. We also discuss some general topics related to the software development career.
Edward Crookshanks
Appendix B. Discussion Questions
Abstract
This appendix will provide some discussion sections and problems for each chapter. The intent is to help the reader think about each topic in terms of how it may be presented in an interview or discussed in a team atmosphere. Some interviews consist of small programming problems; this type of question may also be presented as a small assignment that might asked in a typical job interview or a small prototyping project.
Edward Crookshanks
Appendix C. Database Details
Abstract
On the book’s website there are SQL scripts available for download that will create and populate the example database in both MySQL and MS SQL Server Express. Due to slight syntax, naming, and design differences between the two there are two separate scripts for creating the database – one for each product. Although scripts to seed the database with data are broken down into several scripts, they work both on both products. This section discusses the creation script differences and also shows examples of the  statements, but the full content of the scripts is not given here. Also, this section is not meant to be a full tutorial on creating a database; it is merely an introduction to the topic with some brief samples.
Edward Crookshanks
Appendix D. Bibliography
Abstract
Arking, J., and Millett, S. (2009). Professional Enterprise .NET. Indianapolis, IN: Wiley.
Edward Crookshanks
Backmatter
Metadaten
Titel
Practical Enterprise Software Development Techniques
verfasst von
Edward Crookshanks
Copyright-Jahr
2015
Verlag
Apress
Electronic ISBN
978-1-4842-0620-1
Print ISBN
978-1-4842-0621-8
DOI
https://doi.org/10.1007/978-1-4842-0620-1

Premium Partner

    Bildnachweise