Specialized Topics

XML Parsing
1. What is XML
  1. HTML-like language (XHTML is application of XML)
  2. Custom tags instead of predefined
  3. Strict grammar
  4. Standard format for data interchange
  5. <messages> <message index="1" epoch="1318236815692" from="paul.devrieze@gmail.com"> <h1>Welcome to Programming 2</h1> </message> </messages>
2. Structure
  1. What in computer science is called a tree
    1. what is a tree?
  2. One root, has any number of children.
  3. Every child has one parent.
  4. Children can have any number of children
  5. A child without children is called a leaf
  6. The elements of a tree are called nodes
3. Parsing /chat/messages
  1. parseMessages(XMLPullParser in,...)
  2. On END_DOCUMENT return the stored list of messages
  3. On START_TAG (assuming <messages>) call parseMessagesRoot(in,...). Store resulting List<Message> as local variable
4. Reading XML docs
  1. standardized parsers that do much of the heavy lifting
    1. DOM - Document Object Model (builds a tree for your in memory)
      1. parsing depends on recursion
    2. SAX - Simple API for XML (Invokes methods in handler during parsing, push based)
    3. STAX - STreaming API for XML (Ask for the next event, pull based)
      1. Fast + strightfoward
      2. parsing depends on recursion
      3. Android does not have standard STAX, but does have XMLPullParser (slightly different API, same principle)
5. XMLPullParser approach
  1. Ask for next() node type (skips comments)
  2. Have a loop containing a Switch on the type. Handle START_TAG different from TEXT, END_TAG and END_DOCUMENT.
  3. Handling START_TAG by separate method that returns when it sees an END_TAG
  4. Stop the loop on END_TAG or END_DOCUMENT (remember a return stops a loop as well
Revision Control
1. Why
  1. Collaboration
  2. Keeping track of versions
  3. Roll-backs
  4. Managing multiple releases
2. Terminology
  1. Repository – The database storing changes with when and by whom
  2. Working copy – A directory with a checkout of the repository where the work happens
  3. Checkout – The process of getting a particular version out of the repository
  4. Update – Getting the latest version into the working copy
  5. Commit – Send a set of changes to the repository
3. VCS Operations
  1. Create
    1. A repository is a database. It contains more than just the files, it maintains a history.
    2. The database must be created before things can be added
    3. Version control databases are generally add-only. Old revisions (and the files) don't get deleted
  2. Checkout
    1. Load a revision (possibly the latest) from the repository into the checkout dir
    2. Private working copy means multiple people can do work without conflict
  3. Commit
    1. Add a change from the working copy to the repository.
    2. The comment matters, it allows you to find back things.
    3. The repository can be configured to check code before commit, or to send out mails afterwards
  4. Update
    1. Get the last changes from the repository
  5. Add
    1. Signal in the working copy that the file should be added to the repository
    2. Becomes part of the pending changeset
  6. Ignore
    1. Some files are auto generated
    2. These files often change often.
    3. They can be recreated on demand
    4. Most revision control systems can be told to ignore patterns of file and directory names
    5. When ignored, files are not proposed for adding to the repository.
  7. Delete
    1. Delete file from future revisions
    2. Generally removes file from working copy immediately, from repository on commit
    3. File is not actually gone
4. Subversion Trunk
Threads
1. Multiprocessing
  1. Multiple programmes can run concurrently on a computer
  2. Supported by multiple cpu's or by dividing up a CPU into timeslices
  3. Each program / task has its own memory space, file descriptors etc
2. Inter Process Communication
  1. To allow collaboration between programmes Inter Process Communication is needed
  2. Using pipes (virtual files)
  3. Using RPC middleware
  4. Using regular files
3. Multithreading
  1. Multiprocessing completely separates instances, multi threading shares most resources
  2. Multi threading allows shared memory. Objects in one thread are present and shared with objects in another thread.
  3. Java has native Thread support
4. Why use multithreading
  1. Do computation in background keeping UI responsive
  2. Handling (slow) I/O while keeping the processor occupied
  3. Programming model is more straightforward than asynchronous I/O
  4. Utilizing multiple CPU(s) and cores
5. Issues with multithreading
  1. What happens on which thread?
  2. How to stop threads to step on each other's feet.
    1. Deadlocks (infinite waiting)
    2. Race conditions (inconsistent data)
6. Thread synchronization
  1. Allows structured communication between threads
  2. Java has synchronized keyword (for method, or block of code)
    1. Hard to get right
    2. Android and Java have utility classes to make this easier
7. Thread in Java
  1. Thread class allows starting of a thread
  2. The thread code is in a Runnable (Thread is a Runnable). End of the run() methods ends the thread
8. Communicating between threads
  1. Shared memory (either synchronized or volatile variables)
  2. Pipes – virtual files that allow passing of data
  3. Message passing
  4. Thread.sleep(), Object.wait(), Thread.interrupt() - Poke the thread for attention (timing not guaranteed)
9. Shared memory
  1. Multiple readers at the same time is fine
  2. Multiple (blind) writers can be fine
  3. Mixing read-only with write-only can be fine
  4. Most writing needs reading (adding 1 to a value)
  5. Unfortunately a modern programming language is a leaky abstraction in the face of multithreading (you want to know about hardware)
  6. Use synchronization.
  7. Synchronization needs an object to synchronize on.
  8. All readers and writers need to be synchronized to the same object
  9. Immutable objects (only final attributes) such as Strings don't need synchronization.
10. Pipes / files
  1. Allow passing of “arbitrary format” byte streams.
  2. Very basic primitive (OS based)
  3. Files are disk based and use OS based synchronization
  4. Pipes are memory based but also OS based.
11. Message passing
  1. Each thread has a message queue
  2. Messages may have a return address
  3. Threads have a message pump (event loop)
  4. Events are processed sequentially
  5. A special message can be used to stop loop
  6. Used for processing GUI events from the OS
Databases
1. Why databases?
  1. To store and retrieve data in a permanent fashion
  2. Databases abstract away the problem of data storage, caching etc.
  3. Databases ensure consistency
  4. Complex structures are hard to store another way efficiently
  5. Handles optimization and indexing
2. What databases
  1. Android: SQLiteDatabase (using sqlite)
  2. Java: JDBC
    1. Interface for connecting with many databases
    2. Database independent
    3. Extensible
    4. Not really straightforward
3. How databases?
  1. Connect to a database
  2. Issue query / execute SQL statement
  3. Retrieve results
  4. Close connection
4. Connecting to a database
  1. You need to declare the database to use
  2. Embedded: Open file, initialise memory data structures
  3. External: Authenticate, allow server to prepare
  4. Connecting Android/SQLite
    1. SQLiteDatabase db; db=SQLiteDatabase.openDatabase ("database.db", null, OPEN_READONLY);
    2. Best way: extend SQLiteOpenHelper
  5. Connect JDBC
    1. final String database= "jdbc:mysql://localhost:3306/"+ "mydb"; Connection db; db = DriverManager .getConnection(database, "myuser", "secretpassword");
5. Issue query / execute SQL statement
  1. Query types
    1. Insert (Create)
    2. Query (Read)
    3. Update (Update)
    4. Delete (Delete)
  2. Frequent queries can be "prepared"
  3. Returns a "Cursor" for reading results
6. Why a "cursor"
  1. Databases can be big
  2. Result sets can be really big
  3. Not all results can be stored/transferred in memory
  4. User might want to process results sequentially
7. Query Android/SQLite
  1. static final String SQL="SELECT * FROM messages WHERE index=?"; Cursor result; result = db.rawQuery(SQL, new String[]{ Long.toString(index)});
8. Query JDBC
  1. static final String SQL="SELECT * FROM messages WHERE index=?"; PreparedStatement stmt = db.prepareStatement(SQL); stmt.setInt(0, index); ResultSet result; result = stmt.executeQuery();
9. Retrieve results
  1. Row by Row
  2. Generic, so "ugly"
  3. Can tell you columns names
  4. If you use wildcards, retrieve (and cache) column indices
  5. Don't forget to close result when finished
10. Close connection
  1. Release resources belonging to connection
  2. Must be called for each connection
  3. Database resources are expensive, reuse them, but close them when not needed for long time db.close();
11. Issues with databases
  1. Used often to store user data
  2. SQL is a language
  3. Do not use string concatenation for variable parts
    1. This is slower, database doesn't know it's the same query
    2. This can be insecure (if the data is not from the program)
12. Android Cursors
  1. Like ArrayAdapter, there is a CursorAdapter
  2. CursorAdapter can use any Cursor
  3. SQLiteCursors are Cursors

Next up

Specialized Topics

Description

Resource summary

Media attachments

Similar

	Created by Bhavit Chhatralia almost 10 years ago