Saturday, 12 July 2014

Skill Gaps & Refresher 3 Months (Object-Oriented Design, Design Patterns, Swift, RoR, Web Security)

Challenge List
  1. DONE Start Developing iOS Apps Today (App Development Process)
  2. DONE Programming with Objective-C (iOS Developer Library) (Except Subsection Links)
    • Key topics {Categories (Only use Properties from Original Class) & Class Extensions (Anonymous Categories allows add own Properties), Private Methods & Properties to Hide Information with Multiple Interface Header Files, Utility Behaviour, Complex Class Split Implementation, Alternative Reusable Code Class Customisation (Inheritance, Delegate Objects), Delegates (User Interaction & Customisation responsibility), Runtime Direct Interaction (Associative References), Protocols & Conforming Class Interfaces (Declared Methods of Expected Behaviour, Optional & Required Methods), Protocol Inheritance from Protocol Superclass, Refactoring Protocols across Multiple Classes, Protocols for Anonymity, Blocks (Code Segment Objects passed like Values to Methods or Collections for Invokation or use with Callbacks upon Task Completion, and ability to Capture & Modify Values & Share Storage from Enclosing Scope of a Method using the __block Variable) & Grand Central Dispatch (Invoke a Block in the Background with Automatic or Custom Dispatch Queues with Priorities and FIFO Order), Type Definition (typedef to Simplify Block Syntax when Multiple Blocks used), Track Blocks and Typedefs with Properties, Capture "Weak" References to "Self" to Avoid Strong Reference Cycles, Methods using Blocks to Simplify Collection Enumeration (Arrays & Reverse Enumeration, Concurrent Execution for Processor-Intensive Code, KVP Enumeration instead of For Loop), Concurrent Operation Queues with NSOperation (Asynchronous Invokation of Scheduled Blocks using Main or Background Queue with Configure Priorities & Dependencies, and Progress Indicators Monitoring State Changes), Error Handling (Delegate Methods, Error Domains, Errors passed back by References, and User Alerts, Custom Error Generation) & Runtime Problems, Exceptions (Programmer Error) using Try-Catch Blocks, Encapsulating Data (Set Instance Variables in Initialisation Methods, Object Property Relationships & Synthesised Accessor Methods to Get & Set Values), Object Lifecycle Management (Object Graph Ownership & Responsibility & Relationships, Memory Management using Pointers to Track Objects on Heap, Avoiding Strong Reference Cycles where a Strong Reference Object Ownership stays Alive Unintentionally, Weak References & Declarations to Manage Ownership, Caching Weak Properties in Strong Variables (Property kept in Memory), Unsafe Unretained References (Classes without Weak Reference Support), Copy, Read-Write Access, Designated Initialiser & Convenience Initialiser, Standard Init Method), Custom Accessor Methods (Automate Builds of Changes to Instance Variables), Lazy Accessor (Delays Property Initialisation until First Requested), Conventions (Consistent Codebase, Prefixing Class & Method Names, KVC & KVO Observation Notifications, Property Getter & Setter, Property Booleans, Property Attributes & Relationships, Dot Syntax & Keypaths), MVC Design Pattern, Interface & Implementation (Public vs Privately Accessible Attributes & Behaviours), Inheritance Chain, Object-Oriented Programming, Opaque-Type Oriented Programming (Dynamic by Wrap Object in Struct), Class Factory Methods, Class Method Prototypes, Literal Notation, Scope of Variables (Local Variables on Stack, Objects on Heap), Parameters, Return Values, Self, Super (Overriding Methods, Nesting Method Calls), Equality Methods & Comparator Operators, C Structures (NSRange, CGFloat), Values (i.e. Primitive Scalar Variable Types), Collection Types (i.e. Array & Truncation Avoidance), Collections to Persist Object Graph to Disk (Property-List Architecture, Archiving & Encoding Complex Data with NSKeyedArchiver), Collection Content Enumeration (Slow Method with For Loops vs Fast Enumeration with NSFastEnumeration Protocol), Enumerator Objects (NSEnumerator) to Support Collections (Reverse Loop, While, Next), Arrays (Queuing, Searching, Checking Indexes, Sorting, Modifying), Conversion between Types, NSValue Object Wrapper (Represent Pointers, Structs, Scalar Types), Selectors & Target-Action Design Pattern }
  3. DONE Concurrent Programming by (Except Subsection Links)
  4. DONE iOS Design Patterns with Eli Ganem (Ray Wenderlich) Luke's Version on GitHub (Except Links)
    • Creational Design Patterns { Singleton (API Services Portal), Abstract Factory }
    • Structural Design Patterns { MVC (Code Separation, Reusability), Protocol, Decorator (Categories, Extensions), Delegation (Engage another Object to Act on Behalf of or in Coordination with), Adapter (Object Wrapper for Standard Interfaces leveraging Protocols), Facade (Hides code by Decoupling it from Interfaces using the System whilst retaining standard API singleton), Composite
    • Behavioural Design Pattern { Observer (Decoupled indirect Object Notifications to other Registered Objects interested in State Changes to comply with MVC and based on Subscribe-and-Publish Model with Subscribers and Listeners), Key-Value Observing (KVO) (Object asks for Notifications of specific Property Changes), Momento Pattern (Captures/Saves and Externalises an Object's Internal State for later Restoration without violating Encapsulation whereby Private Data remains Private), Command (Encapsulate Request or Action as an Object for flexible passing between Objects, storing for later usage, dynamic modification, or placement in queues using Target-Action Mechanism & Invocation), Archiving (Convert Object to a Stream for Saving and later Restoration without violating Encapsulation of Private Properties) }
  5. DONE Git Basics
    • Git-Flow, Git Stash
    • Open Source Community Project Listings
  6. DONE Unlearning Your MBA by DHH
  7. DONE Updated my Littlehumans Website using GitHub Repository
  8. DONE Try and Data Types Intro { NoSQL Data Structures Server DB supporting complex data structures in KV stores. Supported commands include SET, GET, INCR, DEL, SETNX, TTL, EXPIRE, Lists (RPUSH, LPUSH, LLEN, LRANGE, LPOP, RPOP, RPOPLPUSH, BRPOPLPUSH), Sets (SADD, SREM, SISMEMBER, SMEMBERS, SUNION, SUNIONSTORE, SINTER, LTRIM, Other Commands, Hashes (HMSET, HMGET, HINCRBY), SCARD (Set Theory Cardinality), Sorted Sets (ZADD, ZRANGE, ZREVRANGE), Lexographical (ZRANGEBYLEX Autocomplete Demo, ZLEXCOUNT), Producer-Consumer Setup with Blocking Operations on Lists, BLPOP & BRPOP (overcomes Polling delays), Bitmaps, HyperLogLogs API (PFADD, PFCOUNT, Benefits: Data structure that contains the state but not the actual elements and so uses less memory) }
  9. DONE, Gemsets
  10. DONE Pow (Rails & Rack App server)
  11. DONE Atomic vs Non-Atomic Operations
  12. DONE Rails Asset Pipeline { Sprockets Gem middleware serves preferred location of /app/assets for Asset Compression pre-processing (instead of just /public static hierarchy) and pre-compilation for production to /public/assets, Fingerprinting as MD5 for production (Filename dependent on File Contents, config.assets.digest) and Cache Busting, Asset Manifest Files with Directives (processed top to bottom) i.e. require_tree (recursive inclusion) or Sass @imports, File Globbing .*, Controller Specific Asset usage <%= javascript_include_tag params[:controller] %> or <%= stylesheet_link_tagparams[:controller] %> , ExecJS (run JS code from Ruby) }
    • Asset Organisation { 
      • app/assets assets owned by app (custom images, JS, CSS).
      • lib/assets custom library code or shared across apps.
      • vendor/assets assets owned by external entities (i.e. JS plugins, CSS frameworks) }
    • Custom Search Paths used by Sprockets { config.assets.paths << ... in application.rb
    • Custom Index Files for Custom Paths (grouping and simplifying maintenance)
    • Links to Assets 
    • Embedded Ruby (ERB) in:
      • CSS i.e. ___.css.erb (Helper used "asset_path" so path written to asset referenced) (i.e. .class { background-image: url(<%= asset_path 'image.png' %>) } )
      • CSS (Helper used "asset_data_uri" to embed image data directly) and declaring the image as a dependency to ensure they are both re-compiled (avoid runtime errors) (i.e. //= depend_on_asset "logo.png"   #logo { background: url(<%= asset_data_uri 'logo.png' %>) })
      • CSS & Sass (Helper used "-url" and "-path", usage: _ (Ruby), - (Sass), usage for asset classes: image, font, video, audio, JS, CSS) (i.e. image-url("rails.png") becomes url(/assets/rails.png), image-path("rails.png") becomes "/assets/rails.png". Generic form uses "asset-" prefix instead)
      • JS i.e. ___.js.erb (Helper used "asset_path" so path written to asset referenced) (i.e. $('#logo').attr({ src: "<%= asset_path('logo.png') %>" }); } )
      • Note: pre-processor interprets filename extensions from right to left and serves in the order specified in the manifest file
    • Runtime Error Checking { config.assets.raise_runtime_errors = true }
    • CSS Compression (Minification) with sass-rails gem { config.assets.css_compressor = :sass }
  13. DONE Everyday Testing with RSpec by Aaron Sumner
  14. IN PROGRESS Code School Ruby on Rails courses
    • DONE Try Ruby
    • DONE Ruby Bits Part 1 (excellent!)
      • To-Do Active Support Core Extensions
      • To-Do Ruby Bits Part 2
      • To-Do Code TV Screencasts
      • To-Do Pry Screencast
      • To-Do Creating Ruby Gems
      • To-Do Thor Screencast (Build Command Line Utilities)
      • To-Do Special Character Methods Screencast
      • To-Do RVM Screencast
    • DONE Testing with RSpec Levels 1-6
      • Examples & Expectations { Classes, Describe, It, Examples, Expectations, Modifiers (i.e. should), Matchers (i.e. ==) }
      • Predicate Methods & Matchers { i.e. be_<method>) }
      • Comparison Matchers 
      • Matchers { i.e. should... respond_to(<method_name>), be_within(<range>).of(<expected>), exist, satisfy { <block> }, be_kind_of(<class>), be_an_instance_of(<class>)}
      • Model Spec Testing
        • Predicate Matchers { be_valid calls ActiveRecord valid method, match(Regular Expressions),  include(matching items on Arrays),    have_key(matching items on Hashes),  have, have_at_least(n), have_at_most(n)(readability in verification), expect { }.to change { }.by(n)/.from(n)/.to(n)(Expect & Change syntax for readability and chaining),  .to/.not_to/.to_not raise_error(<insert_error>)(Modifiers that Raise Errors passing Exceptions),  }
      • DRY (Don't Repeat Yourself) Specs { Implicit Subjects (i.e. subject.should ..., where we let the 'subject' represent the relevant Class), Implicit Receiver (i.e. should ..., where we don't need to prefix with 'subject' or the Class Name, as it's already implied, Parenthesis (i.e. replace it '<description>' do .. end with it { }, as RSpec output displays test automatically without a description),  its(:<method_name>) { }, (use its when calling a Method on a Subject), Nesting (eliminate duplication with describe and it blocks and with before blocks across multiple contexts), Context (alternative to describe blocks Nested), Subject Blocks (specify a custom Subject as an alternative to using predefined Subject with a Class Instance), Let (allow one Subject per Example to deal with Different Objects), Subject Naming & Lazy Evaluation (Aliases the Subject to a Class Instance, Class not instantiated until called through Let and Subject, i.e. let(:<class_instance>) { <class>.create } ...  \n   subject { <class_instance> } or in new syntax simply subject(:<class_instance>), Non-Lazy Evaluation (Class instance created every time when prefixed with exclamation mark i.e. let!   }
      • Hooks {  before(:each), before(:all), after(:each), after(:all) (refactor code inside Before or After blocks so run before every Example and nested contexts in spec)
      • Shared Examples {  (prevent duplication of common Behaviour across multiple different Classes by extracting the common Example into a Shared Example inside the /spec/support/ directory for use across both specs, refer using an Explicit 'Let' (or passing an instance of the Class as a parameter to the shared example) instead of an Implicit Subject  when setting the shared expectation) } 
      • Tags & Configuration { tagging blocks with Metadata to Filter and only run specific specs from command-line or as specified in spec_helper.rb (i.e. context ...., focus: true do    rspec --tag focus spec/lib... ), alternatively exclude slow tests with slow: true do    rspec --tag ~slow spec/lib... ) }
      • Mocks & Stubs { Stub Dfn: fake call to a method that has had its code replaced to return a specific result, Mock Dfn: Stub out with expectations that the method gets called; Stub Objects (stub out with fake object creation and methods that returned stub objects we create to increase speed by preventing unnecessary ActiveRecord objects being created i.e. for Named Stubs replace let(:<class_instance>) { <class>.create(....  with  let .... { stub(:<class_instance>, ... ; Mocking with Return Values and checking Params (i.e. it  { <class_name>.should_receive(:<method_calling>).with(<param1>, <param2>).and_return(<return_value>) } )
      • Other Stub Options { <insert_method>.should_receive(:function).once/.twice/.exactly(n).times/at_least(n).times/at_most(n).times/.any_number_of_times/.with(no_args())/.with(any_args())/.with("A", anything())/.with(2, kind_of(Numeric))/.with(/xyz/) }
      • Custom Matchers { in, i.e. a custom matcher 'validate_presence_of_xyz' is called with custom parameters (so any inputs may be passed to the custom matcher) from the expectation block in our test suite and invokes code in the custom matcher file located in the /spec/support/ directory, which contains a Module encapsulating a Class and a Method named 'validate_presence_of_xyz', which we wish to instantiate.  Configure Custom Matchers below the Module (specific the type for matcher to only be available to certain specs (i.e. RSpec.configure ...  \n  config.include ValidatePresenceOfXyz, type: :model) .  Convert to Reusable Custom Matcher (by accepting the custom parameter as an attribute, and then storing it in an instance variable in an initialize method of the class for subsequent usage). Custom Matcher Failure Messages (use interpolation in the methods of the Custom Matcher that save and display useful failure feedback). Chained Custom Matchers (Shoulda Gem) (i.e. it { should validate_presence_of(:___).with_message('__') / should ensure_inclusion_of(:___).in_range(0..-1), should have_many(:__).dependent(:__).class_name(__)(multi-line chaining separation after each full-stop)  }
      • Console & Configuration { i.e. replacing Default RSpec Mocking & Stubbing with To-Do Mocha, Custom Outputs (colour, verbose, nested), Blanket and Specific Testing }
      • Debugging { to-do list (remove do/end from 'it'), xit, pending) }
    • DONE CoffeeScript Levels 1-6
    • DONE Shaping Up with AngularJS
    • To-Do Rails for Zombies
  15. DONE Amazon Web Services (AWS) Essential Training
  16. AWS Technical Professional
  17. DONE RubyMotion for Rails Developers by Jack Watson-Hamblin
  19. Employment Law
    1. 20% Complete Stewart’s Guide to Employment Law 2013 (4th Edition)
  20. Programming Ruby: The Pragmatic Programmer's Guide
  21. RailsCasts
    • DONE Episode #133 Capistrano Gem (deployment of rails apps) GitHub Link { customise automation of tasks for deployment to web servers, run with: cap deploy}
    • DONE Episode #264 Guard Gem LiveReload Gem (auto-refresh browser) { code changes trigger automated testing as defined in Guardfile }
    • DONE Episode #285 Spork Gem + Guard-Spork Gem { speed up load time of each TDD test suite by shifting code to be preloaded into prefork block of spec_helper.rb, then from terminal tab #1 run server with spork, and then run specs in tab #2 through spork with rspec . --drb, automated with Guard-Spork }
    • DONE Episode #366 Sidekiq Gem (alternative to Resque's non-multi-threaded environment) GitHub Link + Pygments API (code snippet syntax highlighting) + To-Do #367 Celluloid + To-Do #104 Exception Notifications (multi-threaded concurrent processing in Ruby) { 
      • define a worker class with methods comprising work to be done and include a Sidekiq::Worker module. assign priority weightings for the queue. call it with <class_name>.perform_async(<parameter>) or .perform_in(1.minute...) for delayed processing (i.e. clearing cache), passing in a simple object (like an id) to be dealt with as a local variable after being serialized by Redis Server. this will add it to a Redis Server and trigger the method to process the work to be done in a job queue asynchronously. this moves calls to a web service to a background process and prevents delays directly impacting the user. it leverages the Redis Server through Sidekiq server and client middleware to manage its job queue. run it and listen for new jobs with the command bundle exec sidekiq. monitor workers by mounting (in routes.rb with mount Sidekiq::Web, at: 'sidekiq/') a Sinatra web interface that must be secured for production in a rails app at localhost:3000/sidekiq that displays Sidekiq status (jobs processed, failed, busy workers, scheduled workers, retries pending, queue backlog) 
      • Note #1: only allow and use thread safe code and libraries (i.e. avoid defining mutable class variables) to be used by Sidekiq Workers to avoid sharing data that is mutable b/w instances when working with threads 
      • Note #2: change pool size limit to 25 (default only allows 5 threads to connect to db at a time) in database.yml (config file) 
      • Note #3: Sidekiq config file (sidekiq.yml) for custom options } 
    • DONE Episode #402 Better Errors Gem + Binding of Caller Gem {  local and instance variables shown in browser at point in time with interactive prompt in stack trace, clicking filename in errors opens it in editor for rectification (setup with BetterErrors.editor = :sublime if defined? BetterErrors in initializers/better_errors.rb, going to localhost:3000/__better_errors shows last exception that occurred } + RailsPanel Gem { Chrome Plugin for debugging }
  22. Poltergeist (PhantomJS driver for Capybara testing)
  23. (Continuous Delivery)
  24. Rails Tutorial (Urgent Book Refresher)
  25. Ruby on Rails Guides
  26. Ruby Koans (Urgent Koanathon required!)
  27. Functional Programming with Swift and associated beta GitHub Code 
  28. The Swift Programming Language (iBooks)
  29. Concurrency Programming Guide (iOS Developer Library)
    1. Threading Programming Guide (iOS Developer Library)
  30. Visual Paradigm Agile Software (Other Design Patterns)
  31. Pro Objective-C Design Patterns for iOS and Sample Code by Carlo Chung (potential purchase)
  32. iOS 7 SDK New Features with Simon Allardice (Lynda)
  33. Objective-C Essential Training with Simon Allardince (Lynda)
  34. Foundations of Programming: Data Structures with Simon Allardice (Lynda)
  35. Foundations of Programming: Web Security with Simon Allardice
  36. iOS App Development Essential Training with Simon Allardice (Lynda)
  37. Apple Swift Blog (Apple Developer)
  38. Foundations of Programming: Object-Oriented Design (Java) with Simon Allardice (Lynda)
  39. UIConf 2014 Videos
  40. Apple App Distribution Guide (iOS Developer Library)
  41. Core Data for iOS and OSX with Simon Allardice (Lynda)
  42. C Sharp
  43. Unity3D
  44. Coursera (Unlimited Information Age Courses... )
  45. Software Engineering & Computer Science Review (USYD) Target by June 2015.
    • Data Structures & Algorithms
    • Operating Systems 
    • Database Systems
    • Systems Analysis & Design
    • Object-Oriented Application Framework Design
    • IT Project & Systems Management
    • IT Security & Management
    • Web Software Platforms & Technologies
    • User Experience (UX) Design aka Human-Computer Interaction (HCI)
    • Enterprise Systems Software Architecture 
    • Software Quality Engineering
    • Information Assurance & Audit




Job Opportunities

Miscellaneous Employment Law and Startup Equity Links
Other To Do's (thanks Apple)

iOS Frameworks
iOS Testing & Debugging
Memory Management
Special thanks to Mike Shaw and a Confidential person for guidance and mentoring to help me identify skill gaps!

Notes: DONE implies that I have entirely read, listened, and understood 100% of the document and summarised it separately for my own reference (so I don't have to read it all over again). If you'd like to save yourself some time, please contact me.

1 comment:

  1. Did you know that that you can generate cash by locking premium pages of your blog or website?
    To begin just join AdscendMedia and embed their Content Locking widget.