Upload
elvis-plumer
View
227
Download
1
Embed Size (px)
Citation preview
• Length of lineso hours were a zoo the same week the survey was released.
Never seen lines so long or expect to see them as bad again.o even though we have 150 hours of help a week, lines were
still too long• Socratic Methodo TAs are carefully trained during TA camp, here to support not
to tutoro they will NOT give you the answers or tell you if you are
correct or not
TA Hours
• What we’ll fixo dates for last few assignments were on weekend where fewer hours were
held. For future programming assignments, this will not be the case.o we will change hours for the final projects and will be increasing them
around final project deadlines
• What you’ll fixo start early, start now, start yesterday: very little wait the first week of Doodle
Jumpo this week hours have also been almost empty, so start Tetris while it is easy
to get your questions answeredo come prepared with a specific question or bug, so that the TA can work with
you effectively to help you
TA Hours
• Timelinesso projects are graded and returned before early hand-in of next assignmento DQs are returned the night that they are turned in, so students can start
work right awayo one project for one student takes an hour overall to grade (from the time
a TA takes to go through code plus discussion/clarification from HTAs/other TAs)
• DQso due on Sundays at 2pm, so that TAs can immediately grade during
weekly Sunday meetingo these are due BEFORE the help session because students are expected
to have thought about and worked on the design before the correct answers are explained in the session
Grading
• Consistencyo all TAs work off a common rubric. Most work is graded
during a weekly meeting with all TAs to ensure we are consistent
o as the course progresses, we will be getting stricter about things like design and style
o can always appeal grading complaints to the HTAs and/or Andy
Grading
Introducing… Maps (1/3)
● Maps are used to store (key, value) pairs, so a key is used to lookup its corresponding value
● (Word, Definition) in a dictionary● (Brown ID, Person), in banner● (Name, Phone #) in a contacts list● (Identifier, Memory address) in compiler –
called symbol table12/33
Introducing… Maps (2/3)
● In Java, use the java.util.HashMap<K,V> class● In general, this structure is often called a hash table● Other structures to accomplish this goal include
TreeMap, Hashtable, LinkedHashMap, and moreo each has its own advantages and drawbackso we will focus on HashMap
• HashMaps have constant-time insert, removal, and search. We will explain why shortly 13/33
HashMap Syntax
● Like other data structures, need to specify the type of elements we put in
● However, this time we need to specify the type of both the key AND the value
● The Key and Value can be instances of any class
new HashMap<KeyClass, ValueClass>();
14/33
HashMap Syntax● If we wanted to map an Integer to its String representation HashMap<Integer, String> intTable = new HashMap<Integer,
String>();
● If we wanted to map a TA to his/her Birthday HashMap<CS15TA, Date> birthdayTable = new HashMap<CS15TA,
Date>();
● In all cases, both key and value type must resolve to a class
● Note: Can’t use <int, boolean> because both int and boolean are primitives, not classeso cannot use a primitive type as a generic, so use a built-in class that is equivalent to
that primitive (wrapper)
● Instead use <Integer, Boolean> 15/33
java.util.HashMap Methods (1/2)//K refers to the type of Key, V to type of value.//adds the specified key, value pair to the tablepublic V put(K key, V value)
//returns the value to which the specified key is mapped, or null //if the map contains no mapping for the key//Note on parameter type: Java accepts any Object, but you should //supply the same type as the keypublic V get(Object key)
//returns the number of keys in this hashtablepublic int size()
16/33
java.util.HashMap Methods (2/2)//Note on parameter type: Java accepts any Object, but you//should supply the same type as either the key or the value
//tests if the specified object is a key in this hashtablepublic boolean containsKey(Object key)
//returns true if the hashtable maps at least one key to this valuepublic boolean containsValue(Object Value)//removes the key and its corresponding value from the hashtable//returns value which the key mapped to, or null if key had no mappingpublic V remove(Object key)//More methods in JavaDocs
17/33
Finding out your friends’ logins (1/4)
● Given an array of CS students who have the properties “csLogin” and “real name”, how might you efficiently find out your friends’ logins?
● Givenso String[] _friends, an array of your 30 friends’
nameso CSStudent[] _students, an array of students
18/33
● Old Approach:for (int i=0; i < _friends.length; i++){ //for all friends for (int j=0; j < _students.length; j++){ //for all students if (_friends[i].equals(_students[j].getName())){ String login = _students[j].getLogin(); System.out.println(_friends[i] + “‘s login is “ + login +
“!”); } }}
● Note: Use String class’ equals() method because “==” checks for equality of reference, not of content
● This is O(n2) – far from optimal
Finding out your friends’ logins (2/4)
19/33
● An approach using a HashMap:o Key is nameo Value is logino Use name to look up login!
Finding out your friends’ logins (3/4)
20/33
● An approach using a HashMapHashMap<String, String> myTable = new HashMap<String, String>();for (CSStudent student : _students){ myTable.put(student.getName(), student.getLogin());}for (String friendName : _friends){ String login = myTable.get(friendName); if (login == null){ System.out.println(“No login found for “ + friendName); continue; } System.out.println(friendName + “‘s login is “ + login + “!”);}
● What’s the runtime now?● O(n) – because each insert and search is O(1); much
better!
Finding out your friends’ logins (4/4)
21/33
Counting frequency in an Array (1/4)
● How many times does a given word show up in a given string?
● GivensString[] _book, an array of Strings containing many wordsString _searchTerm, the String you’re looking for
22/33
Counting frequency in an Array (2/4)
int wordCounter = 0;for (String word : _book){
if (word.equals(_searchTerm)){wordCounter++;
}}System.out.println(_searchTerm + “ appears “ + wordCounter + “ times”);
23/33
● When tracking one word, code is simple● But what if we wanted to keep track of 5
words? 100?● Should we make instance variables to count
the frequency of each word?● Should we iterate through the _book for
each of the search terms? Sounds like O(n2)...
Counting frequency in an Array (3/4)
24/33
HashMap<String, Integer> counter = new HashMap<String, Integer>();
for (String currWord : _book){ if (counter.containsKey(currWord){ Integer count = counter.get(currWord); counter.remove(currWord); count++; counter.put(currWord, count); } else{ //First time seeing word counter.put(currWord, 1); }}
Counting frequency in an Array (4/4)
//_searchTerms is an array of Strings we’re countingfor (String word : _searchTerms){ Integer freq = counter.get(word); if (freq == null){ freq = 0; } System.out.println(word + “ shows up “ + freq + “ times!”);}
Despite increase in search terms, still O(n)
25/33
Map Implementation (1/5)
● How do we implement a Map with constant-time insertion, removal, and search?
● In essence, we are searching through a data structure for the value associated with the keyo similar to the searching problem we have been trying to optimize
● Data structures we have so far:o Runtime to search in an unsorted array is O(n) o To search in a sorted array using binary search is O(logn)o Using a binary search tree, search is also O(logn), but we have faster
insertion and removalo Can we do better than a binary search tree?
26/33
● How about a ternary search tree (each node has at most 3 children)?o O(Log3N)
● Or a 10-way tree with O(Log10N)● Let’s try the runtime for a search with 1,000,000 nodes
o Log101,000,000 = 6o Log2 1,000,000 < 20, so shallower but broader tree
● Analysis: the logs are not sufficiently different and the comparison (basically an n-way nested if-else-if) is far more time consuming, hence not worth it
Map Implementation (2/5)
27/33
Map Implementation (3/5)
● Try a radically different approach, using an array● What if we could directly use the key as an index to access
the appropriate spot in the array?● Remember: digits, alphanumerics, symbols, even control
characters are all stored as bit strings– “it’s bits all the way down…”
o see ASCII table o bit strings can be interpreted as numbers in binary that can be used to index
into an array
28/33
Map Implementation (4/5)● But creating an array to look up CS15 students (value) based
on some ID number (key) would be a tremendous waste of spaceo If ID number is one letter followed by five digits (e.g., D00011), there are
26*105 combinations!o do not want to allocate 2,600,000 words for no more than 300 studentso (1 word = 4 bytes)o array would be terribly sparse…
● What about using social security number?o would need to allocate 109 words, about 4 gigabytes, for no more than 300
students! And think about aribtrary names <30 chars, need 2630 !!
29/33
Map Implementation (5/5)
● Thus, two major problems:o How can we deal with arbitrarily long keys, both
numeric and alphanumeric?o How can we build a small, dense (i.e., space-
efficient) array that we can index into to find keys and values?
● Impossible?● No, we approximate
30/33
Hashing● How do we approximate?
o We use Hashingo Hashing refers to computing an array index
from an arbitrarily large key using a hash function
o Hash function takes in key and returns index in array
● Index leads to a simple value or an entire object
● Therefore, a two-step process:o hash to create index, use index to get value
hashfunction indexkey value
array
31/33
Hashing● Array used in hashing typically holds several hundred to
several thousand entries; size typically a prime (e.g., 1051)o array of links to instances of the class TA
Greg
Ardra
Sonia
null
null
0
1
2
3
4
N - 1
Hash(‘Greg’)=0
Hash(‘Ardra’)=1
Hash(‘Sonia’)=4
32/33
● An example of a hash function for alphanumeric keyso ASCII is a bit representation that lets us represent all alphanumeric symbols
as integerso Take each character in key, convert to integer, sum integers - sum is indexo But what if index is greater than array size?o Use mod, i.e. (index % arrayLength) to ensure final index is in bounds
● A better hash functiono take a string, chop it into sections of 4 letters each, then take value of 32 bits
that make up each 4-letter section and XOR them together, then % that result by table size
● Almost any reasonable function that uses all bits will do, so choose a fast one, and one that distributes more or less uniformly (randomly) in the array to minimize holes!
Hash Functions
33/33
Collisions● If we have 6,000 Brown student names that we
are mapping to Banner IDs using an array of size 1051, clearly, we are going to get “collisions” where different keys will hash to the same index
● Does that kill the idea? No!● Instead of having an array of type Value, we
instead have each entry in the array be a
_head pointer to an overflow “bucket” for all keys that hash to that index. The bucket can be, e.g., our perennial favorite, the unsorted singly linked list, or an array, whatever…
● So, if we get a collision, the linked list will hold all values with keys associated to that bucket 34/33
Collisions● Since multiple objects will typically hash to the same
bucket, for methods like get(key) and remove(key), HashMap will have to iterate through all items in the hashed bucket to get or remove the right object
● This is O(k), where k is the length of a bucket – it will be small, so brute force search is fine
● The best hash functions minimize collisions● Java has its own efficient hash function, covered in CS16● A way to think about hashing: a fast, large intial division
(e.g., 1051-way), followed by a brute force search over a small bucket – even bucket size 100 is fast!
35/33
HashMap Pseudocodetable = array of lists of some
sizeh = some hash function
public put(K key, V val): int index = hash(key) table[index].addFirst(key,
val)
O(1), if h() runs in O(1) time
public V get(K key): index = hash(key) for (k, v) in table[index]:
if k == key: return v return null //key not found
Runs in O(k) time, where k is size of bucket, usually small
Note: LinkedLists only hold one element per node, so in actual code, you would need to make a class to hold the key and the value 36/33
HashMaps… efficiency for free?
● Not quite● While put() and get() methods run in O(1) time, each
takes more time than inserting at the end of a queue, for example
● A bit more memory expensive (array + buckets)● Inefficient when many collisions occur (array too small)● But it is likely the best solution overall, if you don’t need order● No support for ordering
o (key, value) pairs are not stored in any logical order
37/33
Lecture 20A Brief History of Computers & Programming
LanguagesSee The Innovators: How a Group of Hackers, Geniuses, and Geeks Created the
Digital Revolution by Walter Isaacson. Copyright © 2014 by Walter Isaacson
In the beginning…(1/4)● Long history of mechanical computing
devices (adders) as part of development of clocks, orreries, elaborate music boxes and instruments o based on cogs on wheels, carry mechanism
o 1645: Blaise Pascal creates the Pascaline adding machine – up to 8 dials
o 1671: Leibniz Calculating Machine could add, subtract, multiply, and divide
1 of 24
Music Link: https://www.youtube.com/watch?v=P0FxZUrIB5M&index=2&list=RDtds0qoxWVssMuseum dedicated to mechanical music making: http://www.museumspeelklok.nl/Agenda/Rondleiding
In the beginning…(2/4)● 1822: British inventor Charles Babbage proposed idea of
mechanical calculation to compute polynomials (for ballistics, longitude tables) - designed but never built the Difference Engine
● Then proposed combining mechanical calculation with idea of feeding instructions to a more powerful machine via punched cards in the style of music boxes and the Jacquard Loom, thus designing the first(mechanical) computer, the Analytical Engine
o first had to invent machine tools for the precise machining required, but never completed the Analytical Engine
o but the “architecture” is strikingly similar to the essence of modern computers: driven by instructions; arithmetic unit, memory, input/output
Jacquard Loom
Charles Babbage
Punch cards on a Jacquard Loom
2 of 24
Difference Engine● A modern implementation of the difference engine
was finally completed by the London Science Museum in 2002
3 of 24
Analytic Engine
● Babbage’s son built a small part of his analytic engine in 1910, and the Science Museum has begun the process of building a compete version
4 of 24
Ada Lovelace
In the beginning…(3/4)● ~1845: Augusta Ada Lovelace, Lord
Byron’s daughter, writes program tocalculate Bernoulli numberso first known computer program and programmer!o written for Babbage’s analytical engineo “machine does exactly what you tell it to do”o “the Analytical Engine weaves algebraic patterns
the way the Jacquard Loom weaves flowers and leaves”
o Ada programming language named in her honor was a DOD-sponsored language for writing complex programs using software engineering principles, including Abstract Data Types
A piece of the analytic engine (photo from the Science Museum of London) 5 of 24
In the beginning…(4/4)
● In the 1900’s specialists programmed “business machines" (note IBM’s original name) by actually changing hardware’s wiringo advanced models used plug boards - try to debug that!
● 1946: J. Presper Eckert and John Mauchly at University of Pennsylvania built Electronic Numerical Integrator and Computer (ENIAC) – see http://ftp.arl.mil/mike/comphist/eniac-story.htmlo first electronic general purpose “automatic” computer, used for ballistics
and bomb calculationso 18,000 vacuum tubes, MTBF of 20 minutes!o still programmed by wiringo 5,000 adds/ subtracts/sec, 400 multiplies/sec, 35 divisions or square
roots/sec (10 digit numbers)o men wanted to build h/w, left less prestigious programming to the all-
female corps of programmers, called “computers”, a 19th century termo http://www.npr.org/blogs/alltechconsidered/2014/10/06/345799830/the-
forgotten-female-programmers-who-created-modern-tech6 of 24
Stored Program Computer Architecture● 1945: John von Neumann introduces seminal concept of “stored program”
o “it’s bits all the way down…” for both data and instructionso program can be stored in main memory and even treated as data
to be operated on –paved the way for modern computers
CPU
I/O Interface Memory
Address
Data
Control
Sy
ste
m B
us
es
Simplified Processor Architecture
● Simple instruction execution loopo use instruction register to fetch instruction stored
at that address in memory, increment instruction register, decode and execute instruction
o instruction typically is <op-code> <address>o instruction may update memory – even modify
stored program itself, e.g., for loops. Unsafe: use h/w looping w/ index registers
● von Neumann was a polymath: worked on atom and hydrogen bombs, co-invented “game theory”, computational biology, etc.
● CS15 Final Project Othello uses the minimax algorithm 7 of 24
Moore’s Law and the Shrinking Computer● Moore’s (1) “Law”: an observation that over the history of computing
hardware, number of transistors in a dense integrated circuit doubles approximately every two yearso fastest exponential in history
● Smaller feature size, greater density means shorter paths, faster signal propagation in microprocessors
● We benefit not just from microminiaturization of the CPU but also from great electromechanical engineering of peripheral devices (e.g., disk controllers, disks – 40MB was a big disk in the 60s! Dual Meta-4 mini had 32KB, 1MB disk)
● Today’s IBM zEC12 microprocessor (6 cores @5.5 Ghz) has about same computing power as 5,000 football fields worth of our IBM /360 mod 50s (.14MIPS) 50 years ago - mainframes still selling!
● See http://www.eweek.com/servers/slideshows/a-look-at-mainframe-history-as-ibm-system360-turns-50-cobol-turns-55.html/
● But are silicon chips hitting a limit?
● What’s next: biological computers? Quantum computers? 8 of 24 (1) Gordon Moore was the co-founder of Intel and the co-inventor of the integrated circuit, which led to microprocessors, etc.
Computers get Ever Faster, but do they get More “Powerful”?
● Computer is the only Universal Machine!● Yet theoretically only need 6 instructions for ANY algorithm!
o load accumulator (high-speed register) from memory addresso store accumulator to memory addresso subtract contents of memory address from accumulator, store result in accumulatoro jump to memory address (instruction) if accumulator < 0 (“conditional jump”)o read to accumulator from external input deviceo write from accumulator to external output device
● You can buildo add by subtracting negative numberso divide by repeated subtract, multiply by repeated addo If-then-else and loops with conditional jumpo output to printer by write into special memory location 9 of 24
Trade Offs in Power/Complexity of Instruction● Trade-offs
o complexity of instruction (how much it does)o speed of instruction executiono size of instruction set (and can compiler take advantage of them)
● Today’s computerso Complex Instruction Set Computer (CISC) > 500
• started with IBM mainframes in 50s and 60s, now “Intel architecture” dominates o Reduced Instruction Set Computers (RISC) 100 – 300 (simpler but faster instructions)
• major innovation and important in 80s and 90so Intel architecture has adapted best ideas from RISCo ARM architecture also designed in accordance w/ RISC; used in phones, tablets, etc.o emphasis today is on “multi-core” (multiple CPUs per chip) and low-power designso GPUs (Graphics Processing Units) are even more powerful, for games, but also for
data crunching, e.g., scientific simulation (weather prediction, protein folding…)
10 of 24
● Alan Turing (1912 – 1954) – logician, mathematician, first computer scientist● Designed code breaking machine to crack the German Enigma cypher during WWII● Formalized notions of algorithm, computer and mechanized computing in an era that was
very concerned with what was computable and what was not, mechanized mathematics, e.g., undecidability, halting problem, etc….Also started AI, Turing test
● Turing Machine as the simplest possible conceptual device to execute an arbitrary algorithm: device with a writable tape and a read/write head; the logic is in a table
● Table contains the “program” of “instructions” as a “state machine” – if in state i and read 1, do x, go to a next state, if read 0, do y, go to a next state. Simple actions:
1) move the head one square L or R
2) read/write current cell (empty or tally mark)
3) integers represented by equivalent number of tally marks● Universal Turing Machine that could simulate any other TM proof
that one could build a universal “programmable” computer. MIT’s AI guru Minsky showed a 43 state UTM!
● Committed suicide after being prosecuted and “treated” for being gay
Turing, Computability
11 of 24
First, Numeric Machine Language, Then Came Assembly Language (1/2)● 1949: John Mauchly develops Short Order Code
o first assembly languageo provided vehicle for higher-level languages to be developed
● Symbolic code that is 1:1 with machine code
o load accumulator with contents stored at address 4o program translates to machine code via table lookup of opcode, decimal to binary
conversion algoo assembler early example of treating a program as data!
opcode
LOAD 4 0001 0000 0000 0000 0100
memory address
12 of 24
First, Numeric Machine Language, Then Came Assembly Language (2/2)● Must be defined for each processor
o hard-wired for particular processor’s architectureo generated by compilers for higher-level languages
● Modern processors are very complicatedo so writing at assembly language level takes real skillo compilers can optimize code globally for high-level languages, using sophisticated
computation graphso programmers generally optimize code only locally
● Still used today when speed and size counto embedded computers, device drivers, gameso programmer must understand hardware well to use effectivelyo increasingly, C is used as a “machine-independent” assembly language
13 of 24
High-Level Languages● Attempt to make programming more intuitive
o closer to programmer’s concepts (high-level)o further from machine’s concepts (low-level)
● Symbolic code that is 1:N with machine codeo one high-level instruction may become tens or hundreds of machine code instructions
● Most importantly, machine independento avoided vendor lock-ino depended on compiler to translate high-level constructs to computer’s machine codeo thus allows one source program to be used on many target architectures
● Still trying to make languages higher levelo Java guarantees single compilation, same execution on multiple machines via byte
codes: write once, run everywhereo compile to byte code virtual machine; computer will have virtual machine interpreter
14 of 24
High-Level Languages: Important Dates (1/2)● 1957: John Backus et. al. at IBM develop FORTRAN language and compiler
o FORmula TRANslatoro still used today, mostly for scientific computing, highly optimized o for number crunching
● 1959: Committee on Data System Languages develops COBOL, • led by Rear Admiral Grace Hopper, one of first modern • programmers (Grace Hopper Celebration of Women in Computing)
o Common Business Oriented Language, “English-like”, support o for data recordso still tons of legacy code in banks, insurance companies, retail… (Y2K!)
● 1959: John McCarthy develops Lispo LISt Processingo seen as slow, so primarily used only for “AI” projectso Scheme is a modern Lisp-like “functional programming” language 15 of 24
High-Level Languages: Important Dates (2/2)
● 1960: ALGOL 60 standard publishedo ALGOrithm Languageo basis of most popular languages today
● 1964: John Kemeny and Thomas Kurtz at Dartmouth develop BASICo Beginners All-purpose Symbolic Instruction Codeo simple language, meant to be used by beginners
and non-professionals, efficient on microcomputerso was popularized by Microsoft’s Visual BASIC, now
being replaced by JavaScript
16 of 24
Structured Programming (1/2)● 1968: Edsgar Dijkstra writes landmark note: “GoTo Statement Considered
Harmful”o no predictability, can go anywhere in programo leads to spaghetti codeo can’t be understood by programmer or compiler
● New languages would have constructs for common one-in-one-out flows of control for controlled branchingo if/else-if and switch statementso while and for loopso gives sequential, predictable order to code, only controlled branches allowed
17 of 24
Structured Programming (2/2)● Brown’s AM101, AM40, CS11 (CS15 precursors) switched to new
style in late 60’so taught PL/I, then PL/C, using structured programming styleo then, even taught “structured assembly” based on positive experienceso switched to Pascal as a more modern versiono see, we have a rich history of experimentation!
● Too much commercial legacy code was spaghetti!
18 of 24
Next Generation High-Level Procedural Languages
● Emphasize task decomposition, no bundling of data and procedures in objects● 1964: Researchers at IBM develop PL/I
o Programming Language Io designed to synthesize best features of FORTRAN, COBOL, and Algol 60o failed as attempt to be the one general purpose programming language
● 1970: Niklaus Wirth develops Pascalo named for Blaise Pascal, to be educational language
● 1972: Dennis Ritchie at Bell Labs develops Co predecessor named Bo often called portable assembly languageo surpassed COBOL as most popular language
19 of 24
Even OOPLs are Relatively Old● 1967: Ole-Johan Dahl and Kristen Nygaard at Norwegian Computing Centre
develop Simula, SIMUlation Language and first OO programming language, classes
● 1972: Alan Kay, Adele Goldberg, et al. at Xerox PARC develop Smalltalk and the Windows metaphor/GUI
● 1972: Barbara Liskov at MIT develops CLU, with focus on ADT’s (next slide)● 1980: US Department of Defense develops Ada to combat plethora of languages
o ADT’s, Objects, Concurrency…
● 1983: Bjarne Stroustrup develops C++o OO extensions to popular C language -- named C++ as a play on the ++ operator
● 1995: James Gosling et. al. at Sun Microsystems develop Java, a cleaned-up, smaller dialect of C++o meant to be internet and embedded device programming languageo provide facilities for better reuse and safetyo some professionals avoid it because it is seen as inefficient (use C++ or C instead)o Microsoft’s C# is a powerful Java-ish competitor; also Python, Ruby-on-Railso JavaScript is NOT Java, and is only partially an OOP 20 of 24
Barbara Liskov’s Distinguished Lecture at Brown 11/06/14
• Biography: o member of the National Academy of Engineering and the National Academy of Sciences, charter
fellow of the National Academy of Inventors. o ACM Turing Award (the Nobel prize of CS), IEEE Von Neumann medal
• The Power of Abstractiono abstraction is at the center of much work in Computer Scienceo it encompasses finding the right interface for a system as well as finding an effective design for a
system implementationo furthermore, abstraction is the basis for program construction, allowing programs to be built in a
modular fashion.• What I learned from her talk
o ADTs need to describe the behavior, not just the method signatures, return types, error conditions…i.e., the “pragmatics”
o Java and other OOPLs can only provide support for enforcing that subtypes can do what supertypes can – they can’t enforce the idea that subtypes should also exhibit the same behavior
21 of 24
Who “owns” ADT’s?• November 7, 2014• Computer Scientists Ask Supreme Court to Rule APIs Can’t Be Copyrighted• EFF Files Amicus Brief on Behalf of Tech Pioneers in Oracle v. Google Court Battle• San Francisco - The Electronic Frontier Foundation (EFF) filed a brief with the
Supreme Court of the United States today, arguing on behalf of 77 computer scientists that the justices should review a disastrous appellate court decision finding that application programming interfaces (APIs) are copyrightable. That decision, handed down by the U.S. Court of Appeals for the Federal Circuit in May, up-ended decades of settled legal precedent and industry practice.
• Signatories to the brief include five Turing Award winners, four National Medal of Technology winners, and numerous fellows of the Association for Computing Machinery, IEEE, and the American Academy of Arts and Sciences. The list also includes designers of computer systems and programming languages such as AppleScript, AWK, C++, Haskell, IBM S/360, Java, JavaScript, Lotus 1-2-3, MS-DOS, Python, Scala, SmallTalk, TCP/IP, Unix, and Wiki.
22 of 24
Software Engineering (1/2)● 1968: NATO Science Committee addresses “software crisis”
o hardware progressing rapidly, but not softwareo software development seen mostly as craft with too much trial-and-erroro too little has changed – e.g., ACA website debacle! o coins term software engineering
● 1975: Frederick Brooks writes landmark book “The Mythical Man-Month”o says “no silver bullet,” software is inherently complexo complexity can be ameliorated but cannot be cured by higher-level languageso adding people to late project delays it (“9 women can’t make baby in a month”)
● 1990s: Les Hatton develops “30-5-1” ruleo from study of real commercial programso discovered 30 bugs per 1000 lines untested code on average, then only 5 in well-
tested code, and 1 bug still remaining after code in productiono rule held regardless of language, probably still true today! 23 of 24
Microsoft just squashed a 19-year-old software bug. How did it go undetected so long?
● Tuesday, November 11th, Microsoft patched critical bug affecting Windowso bug could potentially allow hackers to remotely control users’ machines
● IBM researchers who found bug say it could have been around for two decadeso Spotting bugs in code can be difficult, even after extensive review
● “This isn't the first time major flaws have taken years to uncover. In 2010, a Google engineer uncovered a 17-year-old Windows bug affecting all 32-bit versions of the operating system and that could be used to hijack PCs. In September, another problem called "Shellshock" was discovered in a free software package built into some 70 percent of all devices connected to the Internet. It could have been introduced as long as 22 years ago, says Chet Ramey, the long-time maintainer of the code.”
Full article here: http://www.washingtonpost.com/blogs/the-switch/wp/2014/11/12/microsoft-just-squashed-a-19-year-old-software-bug-how-did-it-go-undetected-so-long/
23 of 24
Software Engineering (2/2)● Sophisticated development and testing methodologies
o CS17 and CS19 teach students to write tests that inform the implementation rather than write tests that are tailored to the implementation
o goal is to cover both general and edge cases
● Libraries of reusable componentso companies offer well-tested common componentso “plug-n-play” frameworks to connect trusted catalogue partso OO is a good paradigm to make this goal feasible – works well for GUI widgets and
large-scale components (e.g., “Enterprise JavaBeans”, QT Framework)
● CS32: modern software engineering using Java!● Note: new languages and software engineering technologies (frameworks,
IDEs…) still hot subjects, both in industry and in academeo e.g., Apple’s new Swift, positioned as successor to C and Objective-C, see
https://developer.apple.com/swift/23 of 24