Core Concepts

Core Concepts

Code Styles
1. General Principles
  1. Document any deviations
  2. Adhere Principle of Least Astonishment
  3. adhere to the style of the original
2. Least astonishment
  1. Simplicity
    1. Build simple classes and simple methods.
  2. Clarity
    1. Ensure each class, interface, method, variable, and object has a clear purpose.
  3. Completeness
    1. Provide the minimum functionality that any reasonable user would expect to find and use. Create complete documentation
  4. Consistency
    1. Similar entities look,behave the same; dissimilar entities look,behave differently. Create and apply standards
  5. Robustness
    1. Provide predictable documented behavior in response to errors and exceptions. Do not hide errors and do not force clients to detect errors.
3. Formatting Conventions
  1. Indent nested code
    1. Specify the amount of space and use of tabs
  2. Break up long lines
    1. Split long expressions
  3. Include white space not just between lines
4. Naming conventions
  1. Use meaningful names (Including constants instead of literals)
  2. Question excessively long names
  3. Join the vowel generation (don't shorten by taking vowels out)
  4. Use familiar names (for the target domain)
  5. Do not use names that differ only in case
  6. Capitalize only the first letter in acronyms
  7. package Names
    1. Use the reversed, lowercase form of your organization's Internet domain name as the root qualifier for your package names
    2. Use the same name for a new version of a package, but only if that new version is still binary compatible with the previous version, otherwise, use a new name
    3. Use a single, lowercase word as the root name of each package
  8. method Names
    1. Use lowercase for the first word and capitalize only the first letter of each subsequent word that appears in a method name
    2. Use verbs when naming methods
    3. Follow the JavaBeans™ conventions for naming property accessor methods
  9. type Names
    1. Same name for a new version of a package, but only if that new version is still binary compatible with the previous version, otherwise, use a new name
    2. Use nouns when naming classes
    3. Use nouns or adjectives when naming interfaces
    4. Pluralize the names of classes that group related attributes, static services, or constants
  10. field Names
    1. Use uppercase letters for each word and separate each pair of words with an underscore when naming constants
    2. When a constructor or "set" method assigns a parameter to afield, give that parameter the same name as the field
  11. variable Names
    1. Use nouns to name variables
    2. Pluralize the names of collection references
    3. Use lowercase for the first word and capitalize only the first letter of each word in variable name
    4. Establish and use a set of standard names for trivial "throwaway" variables
5. Other conventions
  1. Documentation conventions
  2. Programming conventions Do not repeat statements or expressions, replace with methods
  3. Packaging conventions
Basic Tools
1. Integrated Development Environment
  1. System that combines an editor with language specific support tools, including a debugger
  2. Standard basic features are:
    1. Debugger
    2. Code Completion
    3. Automatic Indentation
    4. Syntax highlighting
    5. Complication error highlighting
    6. Automate common tasks
  3. The master should always work:
    1. Updates to working copies
    2. Changes quickly updated to repository
    3. Commit triggers build and test
    4. System largely automated
    5. Build results often promiently communicated to developers
2. Revision Control
  1. Manga sharing of code between team etc.
  2. Integration in IDE allows to see changes made even in the editor
  3. Going back and forth between revisions
3. Build systems
  1. Generally powerful scripting environments, that do other stuff to.
  2. Automate various tasks related to building software
  3. "Target"s allow a user to specify what needs to be done
  4. Standard systems:
    1. Ant - java
    2. Maven - java project management
    3. Make - For C/C++ (unix)
4. Static analyzers
  1. Compilers are designed to translate software into executable code
  2. Most languages don't enforce conventions neither do compilers.
  3. Conventions can promote correctness
  4. Complex analysis can find bugs in "valid" code
  5. May score code on "correctness" dimensions
  6. Can check for certain broken patterns
5. Code Formatters
  1. Code readability helps understanding,correctness, maintenance
  2. Formatters automatically format code
  3. Help with conformance to code style + consistency
6. Refactoring
  1. When code changes, the design may change along
  2. Changing the organisation of code or design of the system is called refactoring
  3. Refactoring involves aspects such as:
    1. Renaming "things"
    2. Reordering parameters
    3. Introducing Classes or interfaces
    4. Moving Methods
7. Debugging
  1. Step over - go to next line
  2. Step into - go into the function on this line
  3. Step out - go to calling function
  4. Breakpoint - stop execution here, on exception or value change
  5. Watch - Expressions you want evaluated
  6. Local variables - visible in program + value
Collections
1. What is a collection
  1. Object that groups together various objects
  2. used to hold similar data items - cards, msg in chatbox
  3. Arrays are a sort of collections
2. What is Java Collections Framework
  1. group of interfaces and classes for dealing with differing types of collections
    1. Interfaces – abstract data types
    2. Implementations – ready made classes
    3. Methods – static methods that work on collections
  2. encourages code reuse
  3. facilitates interoperability
  4. abstracts complex data structures between easy to understand (common) interfaces
3. Arrays
  1. Size is fixed when the array is constructed
  2. You must be able to predict array size
  3. Items have a fixed index position
4. ArrayListS
  1. Stores stuff in an array (and moves it to a new array if capacity is insufficient)
  2. Maintains entry order
  3. Changing a location is cheap [ O(1) ]
  4. Finding an item is expensive [ O(n) ]
  5. Getting an item at a specified random location is cheap [ O(1) ]
  6. Adding stuff at the end is cheap (in most cases, except when copying is needed) [ O(1) ]
  7. Putting things in the middle or removing things from the middle is expensive [ O(n) ]
5. HashMap (hashing)
  1. Stores key -> value pairs
  2. Key is hashed
  3. Hash is used as index into an array, where the value is stored (often in a linked list)
  4. Finding elements is cheap [ O(1) ]
  5. Removing of elements is cheap [ O(1) ]
  6. Memory need is bigger
  7. Hash key calculation can be expensive
  8. Collection does not maintain order
  9. No random access
  10. Iterating a bit more expensive than arraylists
  11. HashSet
    1. same as HashMap only value is stored in key as well
    2. enforces uniqueness
6. TreeMap/Set
  1. Stores in a tree
  2. Maintains items in key order
  3. Adding, removing and finding items has moderate complexity [ O(log n) ]
  4. Reasonable memory usage
  5. No random indexed access
  6. Iterating a bit more expensive than arraylists
7. Linked List
  1. Every element has a link to the next + or prev ele
  2. Adding an element is cheap [ O(1) ]
  3. Finding an element is expensive [ O(n) ] needs to look from beginning (on average 1/2 n steps)
  4. Removing an element anywhere is cheap [ O(2) ]
  5. Maintains entry order
  6. LinkedHashMap/Set
    1. Combine hashmap/set with linked lists
    2. maintain entry order of adding items to from list
    3. Computational properties of HashMaps
8. Deque - Double ended queue
  1. New in jdk 1.6 / Java 6
  2. Like array list, but instead of a window starting at index 0 of the array, maintains a sliding window over the array.
  3. Cheap adding/removing entries at beginning of list
  4. A little more expensive because of the index
  5. In general a very efficient data type
Object Orientation
1. References and pointers
  1. pointer is a data type that contains the address of some data in memory
  2. To use the pointed to values, the language must provide indirection operators
  3. A pointer must point to a valid location. Either allocated (new) or pre-existing
  4. A reference is a language feature that makes abstracts pointer indirection and hides the pointer
  5. In Java all Objects are used through references. Pointers are not available
2. What is OO?
  1. A programming paradigm (approach to...)
  2. combination of a number of programming concepts into 1
  3. solution particularly well suited to certain problems
  4. Not a silver bullet / panacea
  5. What makes up OO?
    1. Data structure
      1. Create a new kind of "data" that is built out of constituent components
      2. Members can be contained, or be references to structures
      3. Membership can logically be
        Containment - indistinguishable part, same lifetime
        Ownership - the outer object is responsible for the lifetime of the object, and handling access to it
        Reference - the outer object keeps a link to the object but has no responsibility in its lifetime
    2. Modularisation
    3. Code visibility
    4. Code reuse
    5. Abstraction (Abstract datatypes)
3. What is a Struct
  1. Defines a "sequential" layout of values
  2. Allows treating as parts
  3. Element name is offset into memory
  4. Data / machine oriented
  5. Members are contained in the "in-memory" layout of the type
  6. Containment implies ownership
  7. By default members are public
  8. Structs vs Classes
    1. Java Objects are always used by reference (no containment).
    2. Use of other objects can have the intent of reference, ownership or containment
4. Modularisation
  1. Modularisation is breaking up code into parts
  2. Plain use of methods/functions is not modularisation
  3. module should have some sort of coherency
  4. Makes it easier to find and edit parts of the system.
5. Code Reuse
  1. Good prog reuses code
  2. less code = less complex
  3. reuse = code faster
  4. reuse = effort into better code
  5. reuse = changes in 1 place
  6. Ways
    1. Inheritance - allows a class to use the implementation in it's ancestor.
    2. Generics, allow limited variation on type constraints only (mainly help correctness)
    3. Temp, allow variations preventing copy,paste
    4. ctrl c,v,+ edit = same (bad)
    5. Function implementing an algorithm (Collections.sort)
6. Abstract Data Types
  1. Abstract - "theoretical rather than physical or concrete"
  2. in prog - the what from the how
  3. Comp Science concept
  4. Specifying a data (and its corresponding functions) type purely by its external properties
  5. Allows to reason about something that holds (is true) for all possible implementations
  6. Use in implementation ensures implementation independence
  7. Uses
    1. If your algorithm works on an ADT it works on all types implementing it (code reuse)
    2. Allows for multiple implementations with different strengths (change has local impact on code)
    3. Allow context-dependent use of specific implementation (don't return an empty ArrayList, but Collections.emptyList)
    4. Separate function from implementation
7. Interface
  1. Users should always read documentation for the "hidden" contract
  2. Only specifies an abstract data type
  3. Specifies a particular contract that classes can implement, and users can expect.
  4. Non-visible parts should be documented
  5. Parts of the contract are not visible in code
8. Inheritance
  1. Java = public relationship
  2. class = interface
  3. In memory, an instance is like a structure where the first member is a contained, anonymous version of the parent
  4. Private members allow hiding implementation from children.
  5. Protected allows access by children, but not by users.
  6. Final protects agains inheritance. Final classes can't be inherited. Final members can't be overridden
9. Abstract classes (and methods)
  1. Fully abstract class is an interface (e.g. C++ has no interface concept)
  2. Some implementations are provided either for convenience, or to enforce behaviour.
  3. Abstract methods provide a contract, but no implementation
  4. Abstract classes miss implementation for some methods, and are thus designed for extension
10. Polymorphism
  1. Technique to run different code based on type of an object at run time
  2. Each object maintains a reference to it's actual type (set at creation time).
  3. When calling a method, instead of going to the address of that method, look the method address up in the class (in C++ vtable).
  4. Different classes can point to different implementations for the same method name
  5. Depends on exact method signature match.
  6. Depends on exact method signature match.
  7. @Override annotation conveys intention to compiler that verifies the intention

Next up

Description

Resource summary

Similar

	Created by Bhavit Chhatralia over 10 years ago