1 / 17

The Art of Design

ECE230 Lectures Series. The Art of Design. Ying Wu Electrical Engineering & Computer Science Northwestern University yingwu@ece.northwestern.edu. Outline. Data flow Top-down vs. bottom-up Coarse to fine Two examples MP#2 MP#4. Data Flow. Data

arthur-norris
Download Presentation

The Art of Design

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. ECE230 Lectures Series The Art of Design Ying Wu Electrical Engineering & Computer Science Northwestern University yingwu@ece.northwestern.edu

  2. Outline • Data flow • Top-down vs. bottom-up • Coarse to fine • Two examples • MP#2 • MP#4

  3. Data Flow • Data • data representation  describe your inputs/outputs • E.g. 1: an inputted sentence? • E.g. 2: a segment of a command line? • Inputs and outputs of the building blocks • what are given? • what are expected? • Data flow • blocks are connected through data flow

  4. Flow chart • Coding is a very very small part of programming • design  40% • coding  10% • debugging  50% • The starting point of design • always draw flow charts • organize your thoughts by flow charts • use testing cases to validate your flow charts

  5. Top-down • “Incremental” programming • Divide-and-conquer • Task decomposition • No matter how small a task is, you can always divide it into a set of small sequential subtasks • You need to understand your tasks • Focus • Make the structure clear and neat • Always use the basic controls • Sequential • Selection • repetitive

  6. Coarse to Fine • Coarse  Fine • Coarse design • determines the structure of the program • tells the basic idea • details are all ignored • concentrate on data flow • Organize it by subtasks • Refinement • A rough “block” can always by replaced by a refined flowchart • It is much easier, because the tasks are simpler

  7. Bottom-up • “Brain-storming” programming • Bottom design • creating a set of small “tools” • thinking based on “basic operations” • Bottom  Up • putting tools together • this needs more experiences

  8. “Tools” • Extracting those basic operations • E.g. 1: bypass all “white spaces” • E.g. 2: check digits • Forming functions • inputs • outputs • error checking

  9. Before you start … • Data representation? • How do you represent a “segment”? • st/ed • Your objectives? • Find a segment  determine st/ed

  10. A Coarse Design End of the string? Command line buffer[500] Y N Find the first element of a seg. done Find the last element of the seg. Start the next segment Copy the segment to piece[100] piece screen

  11. Code it int main() { cout << “Welcome bla bla bla” << endl; char buffer[500]; cout << "\nInput a command line: "; cin.getline(buffer, 500); char piece[500]; int st = 0, ed = 0; while( buffer[st]!=0 ){ st = _find_the_first_element( ); ed = _find_the_last_element( st ); _copy_segment(piece, st, ed); _display_segment(piece); st = ed + 1; } return 0; }

  12. Checking after actions End of the string? Command line buffer[500] Y N Find the first element of a seg. N Successful? Y Find the last element of the seg. N Start the next segment Successful? Y Copy the segment to piece[100] Error piece screen

  13. int main() { cout << “Welcome bla bla bla” << endl; char buffer[500]; cout << "\nInput a command line: "; cin.getline(buffer, 500); char piece[500]; int st = 0, ed = 0, err_code = 1; while( buffer[st]!=0 ){ st = _find_the_first_element( ); if (buffer[st] == 0) err_code = 0; ed = _find_the_last_element( st ); // err_code can be set inside if (err_code == 0) break; else { _copy_segment(piece, st, ed); _display_segment(piece); st = ed + 1; } } return err_code; }

  14. Coarse-to-fine st st Find the first element of a seg. ‘ ‘ ‘v ‘ ‘ a‘ ‘ r‘ ‘ _‘ ‘ 1‘ ‘ ‘ ‘ ‘ ‘ a‘ ‘ ‘ ‘ +‘ ‘ ‘ ‘3‘ ‘ .‘ ‘ 1‘ ‘ 4‘ ‘ ‘ 0 buffer[0] st Y buffer[st] == ‘ ‘ && buffer[st] != 0 st ++ N st

  15. Coarse-to-fine Is buffer[st] a letter? st ed Find the last element of a seg. init ed = st Is buffer[st] a ‘[‘? Is buffer[st] a digit? Is buffer[st] a ‘:’? Y N Is buffer[st] an operator? Scan to find ed N Y N Y Scan to find ed Y Scan to find ed Y Scan to find ed err_code = 0 Scan to find ed ed and err_code

  16. Go even finer buffer[st] = ‘[‘ ed Scan to find ed init ed = st+1 buffer[ed] != ‘]’ Conditions for buffer[ed] err_code = 0 break ed ++

  17. Put things together • From coarse-to-fine • always draw flowcharts • keep all your flowchart • Adding things little by little • don’t put together all at once • Validate the new components • whenever you refine a block, always debug it and make sure the whole thing is correct • keep the structure of the program clear

More Related