Chapter 4

Good notation: Sets the brain free to concentrate on more advanced problems and increases mental power of the race.

Arabic notation: Revolutionized mathematics as it allowed easy multiplication and division. Greeks would have found it impossible that a huge proportion of the population of Western Europe could perform division for the largest numbers.

Programming language choice: Affects productivity and code quality.

Familiar language: Increases productivity by about 30%.

High-level languages: Better than low-level languages in terms of productivity, reliability, simplicity, and comprehensibility. C++, Java, Smalltalk, and Visual Basic are high-level languages credited with improving productivity, reliability, simplicity, and comprehensibility by factors of 5 to 15 over low-level languages such as assembly and C.

Expressiveness: High-level languages are more expressive than low-level languages. Each line of code says more. Table 4-1 shows typical ratios of source statements in several high-level languages to the equivalent code in C.

Sapir-Whorf hypothesis: Suggests that the ability to think a thought depends on knowing words capable of expressing the thought. Similarly, programmers may be influenced by their programming languages.

Phenomenon of programmers writing code in a new language using the syntax and conventions of an older language: It has been reported in the industry that programmers write code in a new language using the syntax and conventions of an older language.

Descriptions of programming languages: Ada is a general-purpose, high-level programming language based on Pascal, well-suited to real-time and embedded systems. Assembly language is low-level language specific to a particular processor.

C:

• General-purpose, mid-level language
• Structured data and control flow
• Machine independence
• Rich set of operators
• Portable assembly language
• Developed in the 1970s at Bell Labs
• De facto standard for microcomputer and workstation programming in the 1980s and 1990s

C++:

• Object-oriented language founded on C
• Compatible with C
• Provides classes, polymorphism, exception handling, templates
• More robust type checking than C
• Extensive and powerful standard library

C#:

• General-purpose, object-oriented language
• Developed by Microsoft
• Syntax similar to C, C++, and Java
• Provides extensive tools for development on Microsoft platforms

COBOL:

• English-like programming language
• Developed in 1959-1961 for use by the Department of Defense
• Used primarily for business applications
• Still one of the most widely used languages today
• Updated over the years to include mathematical functions and object-oriented capabilities

Fortran:

• First high-level computer language
• Introduced variables and high-level loops
• “Formula Translation”
• Significant revisions including Fortran 77 and Fortran 90
• Used mainly in scientific and engineering applications

Java:

• Object-oriented language
• Syntax similar to C and C++
• Developed by Sun Microsystems
• Designed to run on any platform by converting Java source code to byte code
• Widespread use for programming web applications

JavaScript:

• Interpreted scripting language
• Originally loosely related to Java
• Used primarily for client-side programming in web pages

Perl:

• String-handling language based on C and several UNIX utilities
• Used for system administration tasks, report generation and processing, and web applications
• “Practical Extraction and Report Language”

PHP:

• Open-source scripting language
• Simple syntax similar to Perl, Bourne Shell, JavaScript, and C
• Runs on all major operating systems to execute server-side interactive functions
• Can be embedded in web pages to access and present database information
• Originally stood for Personal Home Page, now stands for PHP: Hypertext Processor

Python:

• Interpreted, interactive, object-oriented language
• Runs in numerous environments
• Used most commonly for writing scripts and small web applications
• Contains some support for creating larger programs

SQL:

• De facto standard language for querying, updating, and managing relational databases
• “Structured Query Language”
• Declarative language, meaning that it does not define a sequence of operations, but rather the result of some operations

Visual Basic:

• High-level, object-oriented, visual programming version of Basic developed by Microsoft
• Originally designed for creating Microsoft Windows applications
• Extended to support customization of desktop applications, creation of web programs, and other applications
• Beginner’s All-purpose Symbolic Instruction Code

The passage discusses the importance of maintaining conceptual integrity in high-quality software, and the role of architectural and construction guidelines in achieving this. The implementation must be consistent with the architecture, and construction guidelines for naming, formatting, and commenting conventions help ensure low-level harmony. The lack of a unifying discipline can result in arbitrary style variations that make a program difficult to understand. Before construction begins, programming conventions should be spelled out in detail to avoid the difficulty of retrofitting coding-convention details into software after it's written.

Chapter 5:

1. "Software design" refers to the creation of a plan or scheme for developing operational software from a specification.
2. Design is the crucial link between requirements and coding/ debugging activities.
3. A strong top-level design can safely accommodate multiple lower-level designs, making it essential for both small and large projects.
4. Good design is essential for successful software development and is useful for small as well as large projects.
5. Design is associated with various challenges.

Design is a wicked problem:

1. Wicked problems are those that can only be defined by solving them, or solving part of them.
2. The process of solving a wicked problem involves solving it once to define it clearly, and then solving it again to create a solution that works.
3. The Tacoma Narrows bridge is an example of a wicked problem because engineers did not know that aerodynamics needed to be considered until the bridge collapsed.
4. Programming assignments in school are typically not wicked problems, as they are designed to move students in a straight line from beginning to end.
5. Professional programming often involves solving wicked problems, where the design requirements may change multiple times during the development process.

Design is a sloppy process: (Even if it produces tidy result)

1. The finished software design appears well-organized and clean, but the process used to develop the design is messy and full of false steps and mistakes.
2. Making mistakes is part of the design process and is cheaper than recognizing them after coding.
3. A good solution is often only subtly different from a poor one, making design a sloppy process.
4. It is hard to determine when a design is "good enough" and when to stop the design process.
5. Design is an open-ended process, and the most common endpoint is "when you're out of time."

Design Is About Tradeoffs and Priorities :

• Designers must weigh competing design characteristics and strike a balance among them.
• In an ideal world, a system would run instantly, use no storage space, consume no network bandwidth, contain no errors, and cost nothing to build.
• In the real world, designers must balance characteristics such as response rate and development time.
• Designers may choose different designs depending on which characteristic is more important.

Design Involves Restrictions:

• Design is about creating possibilities and restrictions to improve the solution.
• Without restrictions, software can become overly complex and inefficient.
• The constraints of limited resources force simplifications that ultimately improve the solution.
• The goal of software design is to strike a balance between possibilities and restrictions to achieve the best solution.

Design Is Nondeterministic:

• Designing a computer program is a subjective process, and there are usually multiple valid ways to design a program.
• If three people are given the task of designing the same program, they will likely come up with different designs.
• Different designers may have different preferences, backgrounds, experiences, and goals that influence their design choices.
• Designers may also approach the problem from different angles and use different methodologies or tools.
• Therefore, it's important to establish clear design goals and criteria, communicate effectively with stakeholders, and evaluate the trade-offs and risks of different design options.
• Collaboration and feedback can help improve the quality and consistency of designs, and avoid misunderstandings or conflicts.

Design Is a Heuristic Process:

• Design is nondeterministic, meaning there are usually many possible solutions to a problem and no one "correct" way to do it.
• Design techniques are often heuristics or rules of thumb that can guide designers towards a solution but are not guaranteed to produce predictable results.
• Design involves trial and error, and what works well on one project might not work as well on the next.
• There is no one-size-fits-all design tool or technique, and designers must choose the tools that work best for their particular project and situation.

Design Is Emergent:

• Design is emergent, meaning it evolves and improves through design reviews, discussions, and experience.
• Software and physical structures both change over time.
• Most systems undergo design changes during initial development and even more during later versions.
• The degree to which change is beneficial or acceptable depends on the nature of the software being built.

Importance of Managing Complexity:

1. Technical reasons are rarely the primary cause of project failure in software development; poor requirements, planning, or management are more common culprits.
2. Uncontrolled complexity is a significant cause of technical failure, leading to software that is too complex for anyone to understand fully.
3. Managing complexity is the most important technical topic in software development, and it should be the primary technical imperative.
4. The complexity of software development has increased over time, making it even more critical to manage complexity effectively.
5. Dividing software systems into subsystems can reduce complexity and make it easier to focus on one part of the program at a time.
6. Breaking down complicated problems into simple pieces is the goal of all software design techniques, with objects and packages providing ways to separate concerns.
7. Keeping routines short, writing programs in terms of the problem domain, and working at the highest level of abstraction can all help reduce the mental workload for programmers.
8. Programmers who compensate for human limitations can write code that is easier to understand and has fewer errors.

Desirable Characteristics of a Design:

• A high-quality design should minimize complexity, be easy to understand, and allow you to focus on specific parts of the program.
• Ease of maintenance should be a priority, designing for the maintenance programmer and imagining the questions they might ask about the code.
• Loose coupling should be used to hold connections among different parts of a program to a minimum.
• Extensibility means enhancing a system without causing violence to the underlying structure, and reusability means designing the system to reuse pieces of it in other systems.
• High fan-in refers to having a high number of classes that use a given class, while low-to-medium fan-out means having a given class use a low-to-medium number of other classes.
• Portability means designing the system to be easily moved to another environment.
• Leanness means designing the system with no extra parts and avoiding adding extra code.
• Stratification means keeping the levels of decomposition stratified so that you can view the system at any single level and get a consistent view.
• Standard techniques should be used to make the system familiar and easy to understand.