1 / 24

CS50++

CS50++. CS 51 & CSCI E-250 Spring 2013. Greg Morrisett. What’s 51 about?. Programming isn’t hard. Programming well is very hard. We want you to write code that is: Reliable, efficient, readable, testable, provable, maintainable … elegant ! Expand your problem-solving skills:

toki
Download Presentation

CS50++

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. CS50++

  2. CS 51 & CSCI E-250Spring 2013 Greg Morrisett

  3. What’s 51 about? Programming isn’t hard. Programming well is veryhard. We want you to write code that is: • Reliable, efficient, readable, testable, provable, maintainable… elegant! Expand your problem-solving skills: • Recognize problems & map them onto the right languages, abstractions, & algorithms.

  4. What is this course about? Computer Science II: Abstraction & Design • How to engineer solutions to computational tasks. • Decompose goals into solvable sub-units. • Recognize and adapt existing solutions to new problems. • Recognize when problems are unsolvable. • Find and use the right tools for the job. • By “engineer”, we mean to produce good solutions. • Correct, reliable, & secure. • Efficient: time, space, power, money. • Scalable: adaptatable, decentralized. • Elegant!

  5. Course Focus “Software Engineering in the Small” • Introduce new programming abstractions • e.g., closures, abstract & algebraic data types, polymorphism, modules, classes & inheritance, synchronization, events, etc. • increase your computational tool-box, stretch your thinking. • Introduce engineering design • e.g., coding style, interface design, efficiency concerns, testing. • models & analytic tools (e.g., big-O, evaluation models.) • learn to analyze, think, and express with precision.

  6. Who should take this course? • CS concentrators & minors should: • knowledge & experience is crucial for upper-level, software-intensive courses (compilers, OS, networking, AI, graphics, etc.) • 51 : build up abstractions ; 61: drive through abstractions • Also electrical engineering, statistics, [applied] math, systems & synthetic biology, finance, economics, etc. • these fields (and many others) demand computational thinking. • Entrepreneurs • engineering take on design is invaluable. • Necessary background: • basic programming, algorithms, data structures (CS50) • mathematical “sophistication”

  7. What will happen in the course? • Lectures • available online, but come anyway • lots of code walk-throughs, live design • Sections • not just reiterating lecture material • design is best done in small groups • Homeworks & project • homeworks: exercise abstractions, understanding (40%) • project: significant design component (20%) • Exams • mid-term (20%) and final (20%)

  8. (Likely) Problem Sets • Getting up and going with VM & OCaml • Ocaml core language exercises • Moothmatica: Higher-order functions & polymorphism • RSA Crypto, Ocamlmodules • Game trees, priority queues • Moogle: dictionaries, sets, web crawling, page rank • Moosic: refs & streams • Robocows: objects and events

  9. Final Projects • 4 people • Focus on something algorithmically interesting. • goal is to learn some CS on your own. • goal is to experience clean-slate design, testing, construction • goal is to experience working in a team • Many checkpoints • form team and core idea (beginning of March) • functional specification • technical specification • alpha release: basic functionality • beta release: usable by the staff • project video & writeup (before reading period)

  10. Some nice projects • SAT solver • Mini-WolframAlpha • Robobee pollination • BSP trees for representing 3D scenes • Spam filter using Bayesian techniques • Circuit minimization via Binary Decision Diagrams • K-means clustering of genomic data • Compression algorithms • Natural language parsing

  11. Collaboration • First few homeworks must be done alone. • Later homeworks will be done in pairs. • The final project will be done in groups of 4. • The exams, obviously, must be done alone. • Final projects can incorporate other people’s code as long as you acknowledge them. • It’s okay to talk to other students about coding issues, helping to find a bug, etc. • It’s not okay to ask for or reveal a solution to a problem. • When in doubt, go to a TF.

  12. Logistical Information • Web: • http://cs51.seas.harvard.edu/ • See Policies link for issues related to late assignments, collaboration, etc. • 2 late days. Period. Don’t use them. • Books: • Recommended: The Functional Approach to Programming, by Guy Cousineau & Michel Mauny • Augmented by lecture, section notes & articles.

  13. Homework (Today!) Go to the course web site: http://cs51.seas.harvard.edu/ Click on the Piazza link on the left. • sign up for a Piazza account. • check here for announcements. • in particular, office hours for software installation.

  14. Staff: cs51-staff@eecs.harvard.edu KomalSayed (Head TF) Anna Gommerstadt (XO) Gabe Goldberg (CSCI E-250 Head TF)

  15. Course Tools We’ll be using a very different programming environment. • get used to learning languages (not that hard once you’ve absorbed representatives from major genres.) • ObjectiveCaml (a.k.a. ML, Ocaml & F#): • functional & higher-order programming • substitution & environment models of evaluation • types, polymorphism • abstract data types, interfaces, modules • imperative & object-oriented programming • encapsulation, classes, subtyping, inheritance • events, parallelism, concurrency, synchronization

  16. Why focus on functional programming? Functional programming is at the core of each language. • orthogonal design – lets us tease apart abstractions • simple models – closely related to simple math • future proof: half the issues with concurrency disappear • surprising power: higher-order programming • e.g., map-reduce framework from Google

  17. Why Ocaml? Ocaml is a modern functional language: • Alternatives: Racket, Haskell, Erlang, Scala, etc. • Good mix of conciseness, performance: see http://dada.perl.it/shootout/craps_cpumemloc.html • statically typed, type inference • advantages of static typing, conciseness of scripting languages • designed around inductive definitions & pattern matching • promotes good style: e.g., compiler tells you when you miss cases • powerful module system • reifies ideas like interface, implementation, parameterization • integrated object system • a little unusual, but we avoid having to switch languages • Microsoft has released F# (a dialect) as a commercial product.

  18. Language & Code • Language & abstractions matter. • Try formulating an algorithm to multiply Roman numerals. • Often, don’t have the luxury of choosing the language. • We can still conceptualize & prototype using the right language abstractions. • If we understand relationships between linguistic abstractions, we can realize the code in any language.

  19. Example: Red-Black Trees • A particular kind of balanced search tree [Guibas & Sedgewick 1978]. 7 11 4 1 5 15 12 17 0 3

  20. C code (part 1/4) void rb_insert( Tree T, node x ) { tree_insert( T, x ); x->colour = red; while ( (x != T->root) && (x->parent->colour == red) ) { if ( x->parent == x->parent->parent->left ) { y = x->parent->parent->right; if ( y->colour == red ) { x->parent->colour = black; y->colour = black; x->parent->parent->colour = red; x = x->parent->parent; } else { if ( x == x->parent->right ) { x = x->parent; left_rotate( T, x ); } x->parent->colour = black; x->parent->parent->colour = red; right_rotate( T, x->parent->parent ); } } else { . . . /* repeat above with red/black swapped */

  21. C code (part 2/4) void left_rotate( Tree T, node x ) { node y; y = x->right; x->right = y->left; if ( y->left != NULL ) y->left->parent = x; y->parent = x->parent; if ( x->parent == NULL ) T->root = y; else if ( x == (x->parent)->left ) x->parent->left = y; else x->parent->right = y; y->left = x; x->parent = y; } /* repeat above for right_rotate with “obvious” changes */

  22. Ocaml Code for Insert let balance c t1 t2 t3 = match (c, t1, t2, t3) with| ((Blk,T(Red,T(Red,a,x,b),y,c),z,d)| (Blk,T(Red,a,x,T(Red,b,y,c)),z,d)| (Blk,a,x,T(Red,T(Red,b,y,c),z,d))| (Blk,a,x,T(Red,b,y,T(Red,c,z,d)))) -> T(Red,T(Blk,a,x,b),y,T(Blk,c,z,d))| _ = T x let insert x t = match t with | Empty -> T(R,Empty,x,Empty) | T(color,a,y,b) -> ifx <= y thenbalance color(ins x a) yb elseif x > y thenbalance coloray(ins x b)

  23. Who uses Ocaml (or other ML variants)? • Mostly research & education: • INRIA, Microsoft, Google, Xerox, Galois, major universities. • Note: required of all math/cs/science high-schoolers in France. • e.g., advanced compilers & static analyses, scientific computing, visualization, security, networking, etc. • Examples: Astree static analysis tool, Coq proof assistant, • Increasingly, Wall Street: • When billions are on the line, you don’t want an infinite loop. • Example: Jane Street Capital • proprietary trading firm • http://www.janestcapital.com/yaron_minsky-cufp_2006.pdf

  24. XKCD

More Related