1. Coupling & Cohesion CMSC 201- Fall '11

2. Vocabulary Routine- A programming unit that performs a task, such as a function, procedure, method, or main class. (EX.) getValidInt, append Module- A collection of objects that are logically related, such as constants, data types, variables, routines. Component- A routine or module. In python can also be an object or class. Kludge- A clumsy, patchy solution to a problem. Spaghetti Code- When functions use other functions, and tracing your code resembles a bowl of spaghetti.

3. Program Structure Every component should be clear about what it's inputs and outputs are. This makes it so higher level functions can use the lower level functions, knowing that they will accomplish their intended goal. Examples of lower level functions you have written are things such as getValidInt, enqueue, dequeue, pop, push, etc. This leads to component independence.

4. Information Hiding Components hide implementation details. If we have a guaranteed output given some input, then it doesn't matter how this gets accomplished. Examples: How many times in 201 have you appended something onto a list? We don't know the source code for append. How many times have we used Wolfram Alpha to solve math problems for us? At McDonald's, we give money, we get a McRib, and where it came from is not important

5. Component Coupling (The bad) Coupling terminology: Tightly coupled: Many components rely on each other Loosely coupled: Some weak dependencies* Uncoupled: No connections Our goal is to always MINIMIZE coupling. Ways things can be coupled: One component calling another One component passing data to another component

6. Dependencies When a component relies on the successful completion of a different component.  Before you drive your car, you need gasoline  Before you print out a document, you need to plug your printer in.  Before you call your printMagicSquare() function, you need to checkRows() and checkColumns() and checkDiagonals(), so printMagicSquare() is said to be dependent upon the checking functions.

7. Types of Coupling (Still the bad!) Content Coupling: Component directly modifying the control flow of another component Common Coupling: Modifying a common data structure from different components Control Coupling: Booleans or other controls passed between components. Stamp Coupling: Data Structures are passed between components Data Coupling: Primitive data is passed between components

8. Content Coupling A component is directly modifying the control flow of another component This is very poor programming practice, and luckily not possible in python

9. Common Coupling More than one component is modifying a common data structure This is accomplished by global variables Disallowed in CMSC 201

10. Common Coupling (Avoid This!)

11. Control Coupling Passing of control flags as component parameters Unnecessary way to program, and should be avoided New components should be created to avoid this

12. Eliminating Control Coupling

13. Stamp Coupling Passing data structures (such as lists or stacks) to components to use Not as bad as previous kinds of coupling, but still not ideal, and can often be eliminated If we want to print out 100 items from a list, instead of passing a list to a component, the implementation should be calling the component 100 times, each time passing in the element from the list

14. Eliminating Stamp Coupling

15. Data Coupling Not a bad thing...as a matter of fact how functions are called that pass parameters Minimizing this can be difficult, and is unnecessary

16. Component Cohesion Coincidental Cohesion: Components parts are unrelated Logical Cohesion: Logically related task in same component Temporal Cohesion: Performs tasks in sequence related by timing. Procedural Cohesion: Tasks grouped together to ensure mandatory ordering. Communicational Cohesion: Functions produce the same data set. Sequential Cohesion: Output from one function is input to next Functional Cohesion: Every Processing element is essential to the function.

17. Jeff's advice

18. 1. Get a Whiteboard!!! Planning your code before you write it is absolutely essential! White-boards allow you to easily see what your program looks like, and possible holes

19. 2. Learn Languages!!! In my humble opinion: Most everyday useful: Perl or Python Most helpful at UMBC:Java Most fun:PLC scheme Everyone should learn:Common Lisp What to learn next:Anything!

20. 3. Don't code it if you don't get it!!! Why to have something in your code:  You know the expected inputs  You know the expected outputs  You know why it belongs in your code Why not to have something in your code:  If you don't know all three of those ^^^

21. 4. Know when to stop If you are typing the same thing over and over... If you're tired... If you're hungry... If you can't focus... If you get stuck! Your code will deteriorate! Take a break! Take a nap! Have coffee!

22. 5. Take Pride in your code Little feels better than perfectly implemented and executed programming. Have fun...listen to some music, grab some coffee, watch TV, browse the web, enjoy programming!