OnyxRaven

Ruby On Ales Day 2

Fri, 01 Apr 2016 10:00:00 -0700

Baby Driven Development: BDD

Slides
@allie_p - ongoing study and survey on dev+parenting
- more single, non senior, adopted children

similarities

Know how to Google (filtering, right searches)
Earned Dogmatism (close ears to opinions beacuse think you are expert)
Debugging (common issues, inspecting logs (haha), reintroducing single features)
build new features
don’t forget about happiness
pairing is encouraged
learning new things
nobody really knows what they’re doing

challenges

being good mom,developer,employee,wife
parents struggle to keep up
time for projects, code challenges, for new jobs
flexible hours
help with empathy and patience
small percent say hurt, but say slowed or changed (actually hurt?)
no time to waste

solutions

parental leave
work from home, creative working options
support systems,
train managers of parents
realistic expectations
normalize

Thoughts

good things to think about for managers, teammembers and parents
also some just for anyone with interesting/dependent situations

How to stop hating your tests

Justin Searls @searls
Video from RubyConf
why the hate?
- experimentation -> production, some tests. slow -> slaves to tests
prevention
structure, isolation, feedback
structure
- test files too big to fail
  - tests make big objects even harder to deal with
  - rule of product
  - one more argument? double the tests
- too many small things!?
- tests that go off script
  - can do 3 things - setup, invoke, verify, Given, When, Then (and)
  - call out 3 phases in tests
  - make tests clear
  - rspec-given
  - easy to read
  - calls out code smells
- hard to read
  - test code is untested. shouldn’t have logic
  - rspec context vs describe
- framework
  - balance between terse and expressive
- accidental creativity
  - subject, result
  - consistency
  - point out unimportant stuff, important stuff
  - test data should be minimal, also minimally meaningful
isolation
- clear focus
  - define types of tests
  - create suites
  - separate out levels of abstraction
    - unit (mock) vs integration (dont mock)
    - clear rules for each level
  - too realistic
    - realistic are slower, take more time, more complex
    - increase focus on tested vs controlled
    - cant predict unknowns. Might be able to write targeted test after
  - redundant coverage
    - thourough, but redundant
    - how detect? coverage tools - avg hits per line
    - can combine/eliminate test layers?
    - outside-in tdd
  - careless mocking
    - thoughtful isolation
    - can treat test pain as symptom not cause
  - app frameworks
- test feedback
  - useless error msgs
  - long runs
    - throw out tests? (at least skip)
  - false negatives
    - erode confidence in tests
    - redundant coverage
    - poor mocking
    - slow tests
    - track failures, how long to fix, use to improve suites

Thoughts

very quick preso with lots of slides and points
but a lot of tips and tricks, things to keep in mind to make tests better
work on speed because less likely to skip things when it takes too long

a machine state of mind

@vaidehijoshi
Code
dont know what you’re doing, but thats ok
state machine
- state, data, changes
what looks like state machine?
- state or status column
- timestamps with null value
- start_date and end_date
directed graph
acts as state machine
- states
- callbacks
- block passed to state transition, only fires if succeed
- guards

Thoughts

aasm vs workflow
with start/end how to use state machine?
tracking state transitions

In the Name of Whiskey

@juliaferraioli
can i hug that?
- image -> can hug?
whiskey
- managable, objective data
feature vector
- numeric values
- matrix math
- tensor = n dimensional array
tensorflow
- deferred execution
- define compute graph
- tensor object -> matrices , but eval
k-means clustering
- k = number of groupings
- iterative to converge centers
- choosing k important
- initialization of centers is important
tensorflow
- fortran? just use docker image
whiskey k-means
- flavors grouping doesnt quite look like regional grouping
neural network
- input -> ??? -> output
- hidden layer - guides for choosing, lots of math
- each input to each neuron, to output
- init each layer (again, initial state important)
- how to optimize (each iter)
- training, testing
- accuracy
lessons, goals
- pronouncing scotch incorrectly
- data collection is hard
- 86 points not much
- wrong data is still wrong
- thinking in n-dimensions is brain-bending
- bit.ly - k-means-scotch tensorflow-oss ff-nn learn-tensorflow gentle-intro-ml

Thoughts

no ruby interface for tensorflow (sound familliar), but yes python
try TF for recommendation boost, offer ‘rating’, think about what tf would mean for ocr
maybe a talk on something fun like playing a video game via NN learning?

fold, paper, scisors - origami cut and fold problem

@sailorhg - bubblesort zines
Slides
tech and art
paper folding algorithms - provable
any polygonal shape with just one cut - proved
fold so all cuts are all aligned on the same line
angle bisector
- if intersect - straight skeleton
- shrink original shape along bisectors
- stop when shrnk to point
- two edges merge to line as its own
- separate into two disjoint shapes, continue algorithm
shoes + ruby geometry
computational folding theory
not all sets of edges fold flat
extend inner skeleton to edges
how to generalize
- must meet shape edge at 90 degrees
- every internal vertex - wont need them all
mountain valley foldability
- can detect in vs out folds
can generate too many folds
can be used for
- folding solar panels
- 3d modeling?

Thoughts

fun application of algorithm theory
could be a fun project to turn into 3d app showing folds

Crystal Programming Lang

@leinweber
Citus Data - sharding automated
Code
crystal play - online browser for live workbook
ruby inspired
built on llvm
fully self-hosted
static method dispatch
easy to link c
classes are still open
modules + mixins
common idioms (?, trailing conditionals, =, parens, spec framework)
tooling
can chain things in to_procs
union type (compiletime). methods downstream need to be defined (typewise) downstream.
nil can be checked at compiletime
explicit casting
method overloading
abstract classes, abstract methods
touples
Generics (parameterize types)
macros
- method template language, looks a lot like liquid
- can shell out at compile time
no orm yet…
Linking against c code
- since llvm, quite simple. just define interface
regex pcre
profiling c code - instruments on osx
misc
- structs (stack alloc), io (evented!), code formatter (built in), concurrency (channels + coroutines like go)
crystal-lang.org/docs

Thoughts

seems like lang has been around for a while and is still very young
compare to rust
but, way of solving type problems pretty interesting

when good software goes bad

@reinh
sotware fails alot
culture - behavior, beliefs, values, symbols and meanings we share as a group of people
quality - software that is valuable to someone
failure - difference between expectation and observation
process patterns
1. oblivious - dont even know theres a process, not following any process. capable of solving own problem, and you are using it
2. variable - we do whatever we feel like in the moment. poor adherence to process, depend on individuals. separates developer from user. blaming appears.
  - require great relation with customer, competant professionals, not solving a problem too big for team
  - myth - rockstar programmer - completely dependent on performance
  - only follow process when convenient
3. routine - we follow routines (except when we dont). plan to solve all problems
  - depend on plans, managers to implement. exceptional cases are problem
  - problem cant be bigger than small team handle
  - myth - rockstar manager - repeatable, but not repeated. blindly follow process.
  - name magic - ‘agile’, ‘tdd’, ‘lean’ - imbue with powers just saying
4. steering pattern - choose among routines by the results they produce
  - usually management training (not individual contrib)
  - processes not super well defined, but goals well defined. recover if process doesnt work
  - problem hard enough for simple routine to not work
  - some control/negotiate with externaliies. can reject arbritrary schedule/constraint
5. (+1more?) - 85% at variable, 1% at level 3, 0 at 4 or 5
Cybernetic Control
- feedback to make good choices, iteratively
- inputs - resources, requirements, randomness
- outputs - software, outputs
- variable - no controller between inputs and outputs - software somehow comes out
- controller - manages requirements - needs feedback from outputs
nonlinear system
- inputs dont correlate to outputs
- humans really hard at predicting
deal with nonlinear
- governing actions - prioritizing.
- act early, small, often.
- if you can’t see it, it doesnt exist - get visibility
- if you cant understand it, you cant fix it
models
- Mythical Man Month - failure for lack of calendar time - make model explicit
- make model explicit and share them
- implicit - developers will do what i tell them. i can add people to make it go faster. bugs occur at random. the more pressure, the faster they work. I know how to identify best developers
  - characteristic of variable orgs
feedback/control systems needed at all models
- control nonlinear effects
better software - spend time thinking about people

Thoughts

great talk on process, types of process, etc.
obvious that levels are a bit fluid

Ruby On Ales Day 1

Thu, 31 Mar 2016 10:00:00 -0700

Opensource Survival Guide

@blowmage
Slides
3 types of users
- maintainers
  - typically at mastery level
- collaborators
- consumers
Dreyfus Model of Skill Acquisition
- novice
  - rigid adherence to rules, rote recetitation
- competence
  - situational perception, all work equal important
- proficiency
  - coping with crowdedness (more things than able to do)
  - actions in relation to goals
  - planning, routines
- expertise
  - holistic view
  - prioritization
  - own path
- mastery
  - trancend reliance on rules, guidelines
  - deep, tacit understanding
  - based on experience, instinct
  - what is possible
  - analytical approach
documentation
- readme
- rubydoc.info
- guides
- screencasts
- examples
can typically teach down 1 or 2 levels from current
- just hard to know context/view
- effort to do whatever documentation possible, so each level can continue
encouraging contrib
- add a CONTRIBUTING file, and explain setting up dev env, contacting maintainers, running tests, code conventions/style requirements, etc
- rubocop, CI, issue labels (help wanted, easy, docs, etc)
- vagrant/docker
- beginner friendly usergroups
  - LA ROR study groups?
communication
- remote, different skills. technical writing, tone
- “The Box” - Leadership and Self Deception (book)
  - self-deception

Thoughts

applies to any team
concentration on not justifying
step outside box, reconsider situation
be truthful
pairing - screenhero
encourage team to contrib opensource - learn how to contribute (get over intimidation as a group)
RubyTogether - official 501c6 trade org - support OSS

Including People

@indirect - Andre Arko
ruby weird reputation of sexist dudebros?
- old reputation, maybe from early rails?
not diversity, inclusion
bias and exclusion problem
https://jacobian.org/writing/great-documentation/
How to include
- Code of Conduct
- docs (dev and end user)
- issue acceptance
- support is voice of users
how to involve contributors
- ask people for help
- pairing
- ask lots of questions, be honest about whats hard
respect and empathy

Thoughts

similar to the first talk, but still good
more of an experience based talk. Andre works on Bundler

Orbits

@habitmelon
Slides
Code
Geometry rules define space
Model Universe, Rules, Objects
Can model 2 body but not 3

Thoughts

Lots of the math of vectors, etc, explaining what the ruby ended up being
links have the code, which is pushing to a websocket server for realtime position rendering. Kind of a fun idea

Choices

@erniemiller
LivingSocial alums
interactive presentation (websocket omg)
- users make choices, changes the preso
choices have consequences
loss aversion
easy to get distracted from important choices
intentionality - choose your choices.
github.com/ernie/venture

Thoughts

good think-piece on making choices
could be very interesting elixir code

Writing a test framework from scratch

@the_zenspider
github/zenspider
Code
microtest - walk through quick test runner
Done > Good - can make good later
good walkthrough of refining an idea

Thoughts

pretty quick walkthrough of how minitest works, how test framework works

Self teaching for developers

Aja Hammerly
@thagomizer_rb - github/thagomizer
learn
learn hard stuff
‘thinky’ stuff - ideas not skills
build scaffolds for learning more
MOOCS - online courses
- coursera, itunesU, etc
- video, forums, homework, quizzes, tests, structured, vetted. time consuming, feel like school
- read the syllabus
- be realistic about time
Study Groups
rosalind, exercism, project euler
books
- exercises
- onine content
- Elements of Computing Systems - Nisan and Shocken
- Clause and Efect - Clocksin
- The Pragmatic Programmer - Hunt and Thomas
talks
- prolog
- teach right after/during learnings
- do talks, meet people, get jobs
- tips: topic, you want to give. keep simple.
hack week
- team building
- protyping
learning time
- read, hack, watch video
- dedicated time

Thoughts

good ideas for team building, projects, etc
also for personal learning

RubyConf 2014 - Day 3

Wed, 19 Nov 2014 01:30:00 -0800

startups consume opensource
poor contributors
opensource - intersection between philosophy and economics
awfulness vs progress - more as time goes on until theres a breaking point
opensource is progress
- .c and .h files out there randomly
- makefiles help
- jar files
- gemfile (bundler) - dependencies discovered and resolved
- npm - huge tree of dependencies - windows max file path limit
dependencies are hard to update
- come back a year and try to update everything
- downstream changes with loose versioning
- need -> convenience -> complexity -> risk -> mystery
maintainer
- early adopter - awesome, then disappears
- late adopter - stable vs stale - ask for unseen features, ask for more
  - better customres than users? paid options/dual license?
- should be ok to say no, (but help you to do it)
- trolls :-(
- no maintainer is forever
- what happens when maintainer leaves goes away etc
cloud services
- all are going to shut down at some point
- most opensource is centralized from convenience
- what if rubygems/npm disappear? what would decentralized repo look like?
adoption requires trust
- explicit trust vs implicit trust
- marketing
security
- open
- uncomfortable number of people read source to exploit it
- as software gets more popular, importance of audit goes up, but motivation to audit goes down because implicit trust of popular project
communication
- scale up fidelity - chat, pairing, video, in person
systems programmers
- conservative, cautious
- embedded and realtime failures have grave consequences
using dependencies
- understanding debt - outsourcing understanding of a problem

@schneems - Richard Schneeman - Text distance - github.com/schneems/going_the_distance bit.ly/going_the_distance

Edge (edit) distance = cost to change one word into another
Hamming distance (signal distance)
- measures errors in a string, only if same length
- detect and correct erros in binary and telecommunications
- does not include insert/delete, only substitution
Levenstein distance - http://en.wikipedia.org/wiki/Levenshtein_distance
- calculate deletion/insertion
- calculate distance between every substring
- take minimum
- recursive O(n^n) 1647 iterations?
- has a lot of repeats
- calculate with a matrix
  - sorta example
    "" => "saturday" = row 1->7 "" => "sunday" = col 1->6 s -> a = 1 su -> s = (0)+1 sa -> su = (0)+1 sat -> sun = (1)+1 = 2
  - final cost is last entry in the matrix
  - 48 interations m*n
Peter Norvig has paper on how Google did spelling
- word counts - higher count higher probability
- edit distance between words, weighted with probability
- cache found corrections
did_you_mean gem
- in better_errors - helps find no method errors
more algorithms
- Jaro Winkler distance - for large number of distance calculations
- rosetta code

Benchmarking Ruby - github.com/davy/benchmarking_ruby - @davystevenson

why benchmark
- certainty in performance
- benchmark in gems, ruby itself
require 'benchmark'
- Benchmark.bm { report { n.times { stuff } }; }
- Pros: easy, in stdlib
- Cons: variable fiddling, difficult output, boilerplate code
benchmark/ips - iterations per second
- like benchmark
- how many iterations in 100ms
- run for 5 seconds
- comparison
- Pros: a bit less fiddly, measures iterations per second, same syntax, compare
- Cons: gem, snapshot view into performance
benchmark/bigo - determine big-o of operation
- generator, generate array etc
- size changing over time
- print/generate charts
- Pros: range of inputs, charts,
- Cons: gem, longer runtime, not always applicable
- compare, compares to known big-o notation lines
- can constrain parameters of test set
how to benchmark effectively
- is environment consistent?
- verify/test actual results
- dont change behavior over runs
- only modifying one thing?
- accidently mutating objects?
- set controls (understand how other code to setup benchmark affects)
- using random effectively? (is random going to change behavior)
- what are you benchmarking - best case, worst case, or average case?
Terraformer
- converts types
- geography related tasks
- convex hull algorithm
  - jarvis march (simple code) based on input size, worse if points are on edge
  - monotone chain (better, doesnt change based on types of objects)
  - test average and worst cases to pick
Conclusion
- Verify assumptions, control changes
- Learn more about code, ruby
- When Benchmark? just use benchmark.ips
- When Benchmark.ips? all the time? good for spot checks and expansive analysis
- When Benchmark.bigo? range of sizes, results in chart form, ok if it takes a while
More
- Writing Fast Ruby - Erik Michaels-Ober
- Fast ruby repo
- Derailed benchmarks - for rails, ram required over time

Ruby performance secrets - Alexander Dymo

ruby-performance-book.com
how to understand whats wrong, how to find your own perf tips & best practices
how is slow sometimes? garbage collection
how to check object creation / allocation
- profiler - needs patched ruby (railsexpress) - 2.1.4 no patch right now
- gem install ruby-prof
- kcachegrind/qcachegrind
- ruby-prof -p call-tree --mode=allocations > out
- look at source code
- gdb - r -e 'ruby code'
- memoization and block conversion are tough - create objects
func! modify in place (except when it doesnt), should be faster (except when it isnt)
- ruby-prof -p call-tree --mode=memory > out
challenge all tips/tricks/practices
dont guess, profile
do not need patched intrepreter for cpu ruby-prof, only memory/alloc
ObjectSpace. - profiler better for whole view

REAL WORLD RUBY PERFORMANCE AT SCALE - Aaron Quint - @aq - paperless post - github/quirkey /paperlesspost

tips and tricks are the clifs notes of tech learning
step 1: acceptance - its your fault
- x doesnt scale is bs: scale for what? to what degree? with what hardware? etc
step 2: diagnosis
- metrics - measurements - mmmnumbers - milliseconds
- playing golf (lowest num lines/code)
- vertical, request descending through stack - horizontal are tiers
- vertical - single action or code path
- horizontal - more nodes, faster hardware
step 3: treatment
features vs speed - opposing forces
- fast means being stable too
example - json for days - paper browser
- json -> javascript
- cache invalidated
- shared cached sections
- uncached perf still a problem
- ppprofiler
  - benchmark
  - rblineprof
  - notification counts
  - memoryprofiler
  - markdown output
profiling numbers are relative
stackprof and stackprof-remote
- read between the lines, other stuff going on
- samples whats on stack at a given point
- doesnt allocate heap memory, doesnt greatly affect perf
- flamegraphs - tall and wide are places to optimize
sometimes it is your fault, for being cheap, sometimes you can throw money at the problem
start with a hitlist
- start at the top, work way down (most used -> least used)
- number of req * 90% response time = “total worst time”
- like newrelic already has
big wins are not the point
- small changes over time
- keep doing it
if you’re not failing, you’re not being honest
dont just make tools, learn to use them

RubyConf 2014 - Day 2

Tue, 18 Nov 2014 01:30:00 -0800

Keynote - Sandi Metz - MADAM SANDI TELLS YOUR FUTURE

Matz is nice and so we are nice (minaswan)
Scroll -3000 to 0
Romans - Codex (books) - random access. read and write at the same time
Scriptorium - snarky comments -
0 to 1400 - written by hand
1450 - gutenberg
- yak shaving - letter print (swort?) - wear out quickly
- need reliable way to copy sworts
- lost the rights
- print shops
  - upper case and lower case
  - stereotypes - whole pages cast instead of just the individual letters
- still set by hand. newspapers have to do it every day
18x linotype
- dynamicly cast a whole line of type
- machine to create lines of type, molds lead after lining up
- edison called 8th wonder of the world
- newspapers 8 to 48 pages per issue
- newspapers actively recruited deaf employees
- never complain about CSS again
- worldwide literacy
hot to cold type
the fortune : everything will change
- death, decay, obscelence
- the ‘happy path’ of life
- MVP - health, happyness
- contribute
- do for others
- always something that needs doing

Fringe Ruby - 2 + CATS = 4 * CUTE: HOW MATH WORKS IN RUBY - Chris Hoffman - @yarmiganosca - Optoro

numerical coercion
#coerce(numeric) -> array - find a common type between the two operands
- 1.2.coerce(3) => [3.0, 1.2]
Vectors - can we make these work with coerce?
- yes, define coerce and operation(s)
Dimensional analysis
- gem unitary
- size * dimension
Other uses
- currency manipulation (gem conversions)
- balance chemical equations?
- function scaling/composition

Fringe Ruby - A PARTIAL-MULTIVERSE MODEL OF TIME TRAVEL FOR DEBUGGING - Brock Wilcox

pry-byebug (2.0+)
YARV bytecode
- trace codes - hooks into VM state
pry-timetravel
- back to step backwards into previous state
every next, fork and suspend the fork
back, grab most recent child fork
pid = fork
- if pid parent; else child
- $$ = current pid
signals (OS Callbacks)
- Signal.trap
- Process.kill
- SIGTSTP - SIGSTOP (uncatchable) - no io, etc, -> SIGCONT (continue, unstop)
limitations
- can only go back as far as snapshots
- shared file handles, incl sockets
- threads :-( - no copy of threads
- memory exhaustion
complication
- shell detects stop, inside
  - fix : make dummy parent process
- killing parent processes
  - fix : kill the others
  - except everything will have this, so force? Kernel.exit!
- zombies
  - child exited, but parent doesnt waitpid - process is dead, yet remains
  - owned by init
snapshot tree?
- can back to pid
‘snap $cmd’
autosnapshot and prune
- autosnap every stack frame change
other techniques
- yarv - keep track of everything there
- ocaml debugger does fork()
- “why is reverse debugging rarely used” on stackexchange
- elm-lang, watches what is changed

JRuby 9000 - Charles Nutter @headius & Tom Enebo @tom_enebo

Ruby on JVM
- native threads, tooling, JIT
- pull in any java library, ehcache, neo4j, lucene
- other languages, scala, jython, clojure, groovy
JRuby 1.7 == Ruby 1.8 or 1.9 - new releases frequently
JRuby 9 == Ruby 2.2(+) - release mid Jan?
- New runtime
- Major IO & Encoding
timing
- startup time (from command line)
- warmup time (until best performance)
- running time (now running)
indy (invoke dynamic) - high warmup time, lower stable time
MRI - internal representation -> interpreter
Jruby - internal representation -> (interpreter) -> java bytecode -> native code
why not JIT everything? cause warmup is slow.
- JIT creates lots of classes
- more code for the JVM to deal with
benchmarking
- benchmark/ips or perfer
- with warmup/rehearsal time
jvm and jruby are mixed mode - interpreter -> JIT
example
deoptimization (undo optimizations) to try crazy optimizations and rollback if it doesnt work
Jruby –dev (skip jit) faster warmup for dev
Drip - new jvm for next command, like spring preloader
- tell what to preboot, gets faster
New runtime (IR)
- no AST, semantic representation
- traditional compiler design
- no heap allocated arguments, removes extra binding
- add jruby –debug
- compiler optimizations (dead code, constant propogation, inlining, unboxing) - done with pluggable compiler passes
new IO and character Transcoding (M17n)
- MRI gives thin wrapper around fd
- JVM gives Channel, which looks like fd
- old Jruby emulates libc fd
- JDK uses UTF16
- impossible to emulate some POSIX stuff
- new IO layer (OpenFile) - passes nearly all, performance better, match MRI
Old JIT
- 16k loc just for bytecode gen
- one-off optimizations
New JIT
- 95% done
- 56k loc
- equal performance, lots of room to improve
Memory Analysis + debugging
- VisualVM. GC, java object level
- Ruby-centric version
- Alienist - java -> ruby heap dump
  - mri version?
  - size, query language?
  - allow implementation specific data
  - spec for json format
TODOs
- finish JIT
- AOT compiler (jrubyc)
- IR compile & interp speedups
- Refinements
- MRI test suite
How to help
- run master - jruby-head (in travisci)
- openjdk8 oraclejdk8 openjdk7
- rbenv/ruby-build jruby-9(.0.0.0)-dev
- setup for dev - clone; mvn -Pbootstrap;
- run tests/specs, find excluded that is fixed
- fork, create a branch, send a PR
  - implement tagged/excluded
  - mine for bugs (Beginner tags)

Elixr

Thread - lots of ways to shoot self in foot
Built on Erland VM - Erricson labs - telephone switch
Not just a CoffeeScript for Erlang
better tools, syntax, standardlib
Tools
- iex (REPL) - built in doc system, in markdown
- mix (project mgr, create project, manage dependencies, run tests)
pipe operator
- data transformations - (nested fns)
Actor concurrency model
- “Process”
- performs one task
- send and receipt messages, messages are pattern matched to methods
- unshared memory
- Ackermann function
- unprocessed messages are buffered (queued)
Fault tolerance
- supervision tree. supervisors are just processes
- can restart processes, kill them off etc
- keep calm and let it crash
- supervisor heirarchy can take over and put system back together
http load tester example
- coordinator, create workers, track responses
- workers just send message back with result
task is like a future/promise
- runs in a container. await to gather result
distributed
- message passing between processes on network are transparent
Phoenix Framework

MY LITTLE C EXTENSION: LEGO ROBOTS ARE MAGIC - Brandon Hays

about burnout
how to C in ruby
- start a gem, good guide on rubygems
- include ruby.h
- include c dependencies
- magic Init_native to define module, method(s)
- cast C types to Ruby types
- (VALUE self) - own ruby object
- segfaults (yay)
wrap the rest of the API
Style Guide
- Keep low level like C (ugly)
- Low level wrappers in a ::Native module
- prefix c method helpers
C Ext Cheat sheets (links in slides)
atone for cheating :-)
oh no, people are using it
how did it help burnout?
- just doing something for self
- play to get <3 back
- play is how you realize unlimited potential

RubyConf 2014 - Day 1

Mon, 17 Nov 2014 02:00:00 -0800

Keynote - Yukihiro “Matz” - “Feeding the Sharks”

OSS developer community like sharks
- move or die, move somewhere else more interesting
- History of rubyconf announcement/discussions
- exciting new but uncertain ideas
Ruby 3
- (Still lots coming in 2.2)
- Concurrency
  - GIL
- JIT
  - LLVM?
- Static typing
  - ?
  - Scala, Dart, Typescript, ECMA6, Go
  - (python has hints, but not checked) - mypy has optional checker
  - Performance
    - do we need static typing for speed? Maybe JIT is enough
  - Compile Time checking
    - static analysis, refactoring
  - Documentation
    - better than comments/yard
  - why not
    - duck typing
    - optional static to allow overload, but ended up a mess
    - ruby should keep being ruby, w/ duck typing
    - DRY
    - would restrict require, define_method, method_missing (meta programming)
  - -> Soft Typing
    - type inference
    - Type represented as set of methods signatures (or class/module, which are a set)
    - closer communication between compiler and user (ide) - knows methods needed
    - fallback
    - static analyzer

Advanced - I <3 Promises in Ruby - Dinshaw Gobhai - @tallfriend

https://github.com/dinshaw/promises-in-ruby - https://github.com/dinshaw/promises
fn -> promise (respond_to :then) (lambdas)
Uses Thread.new
Fulfill and Reject
- in promise block, call fufill if ok, call reject if rejected
- uses method() turns method names into lambda
- catches all errors, calls reject
All and Any on lists of promises (from spec)
Return a promise immediately
fulfill or reject
chainable

Advanced - Letting Concurrency help you today - Richard Bishop - @rbondev

Great language for getting feet wet in concurrency
Concurrency about dealing with lots of things at once, Parallelism is doing a lot of things at once
parallel - overlapping, no communiciation, concurrent - communication
Primitives - Processes, Threads, Events
Threads
Libraries:
- Celluloid - Actor and Object - pass messages - pools and supervisors
  - Actor -> mailbox -> messages (message queue)
  - Sidekiq -
  - Sucker_Punch - in memory
- Puma
Concurrent Design
Elixr
- Erlang VM, Concurrency as paradigm - actors and message passing
- Supervision tree -
(SOA) - separate processes, message queue
- gives modularity
- now coupled over the network, rely on reliability
Defending ruby
overall a bit too high level for an Advanced track talk. Wanted more actual solutions. Sounds like music would have been better (@lsegal Loren Segal)

Future proofing your 3rd party integrations - @idlehands - Jeffery Matthias

Sendgrid - PHP app being refactored into Ruby (not Go, lol) - PivotalLabs helped them
Keep 3rd party logic out of our code
Make 3rd party behavior predictable
Make 3rd party replacable
Adapter - just a gem. use Gemfile gem '', path: 'relativepath'
- Still wrap your own adapter around their gem
Clearly define internal vocabulary
Use internal vocab, adapt to external (prefer internal as needed)
Use Data Transfer Object (put necessary parameters, validate attributes)
Abstract Service - make interface for the adapter
Adadapter/Interface (gem) - separate from implementation, contains DTO and abstracts. Helps enforce generic use
gem - uptyped - type checking etc
use sandbox when available
create a fake service or user VCR - has to be consistently maintained
use dependency injection - pass the class to be used underneath
CI should hit the sandbox / real code regularly
Flexibility + separation of concerns
Portability (messgage bus, etc)
- DTO helps
- consistent Abstract Interface

GOING EVERGREEN - Kane Baccigalupi - @rubyghetto

Greenfield - new and bright and interesting and easy to work with
Brownfield - old project, ongoing maintenance
how to get it green
SOLID
- Single Responsibility - should only change for one reason
- Open / Closed - open for extension, closed for modification (inheritance)
- Liskov (Substitution) - parent more specific than child
- Interface segregation -
- Dependency Inversion - high level should not depend on low level. abstractions should not depend on details (dependency injection)
- help respond to change. rules are tightly coupled. motivated by change
- great guidelines if you know it already
Sandi’s 5 Rules
STD2
- Small - small classes, small methods. easier to read
- Test drive it
- D2 - Dependency Inject, Law of Demeter (low communication)
Rules dont make code, teams make code
Code is about communication
affective metrics (hiring)
- communicative
- enjoyable
- motivated
- self aware
  - impostor syndrome vs arrogance
  - learning style
  - impact control (how my behavior impact others)
- design - refactoring instinct
- faith - ?

Fighting Bugs with Hacks - Paul Gross - @pgr0ss

If debugging is the process of removing bugs, then programming must be the process of putting them in - E. Dijkstra
Testing is good for showing there are bugs, but bad at proving their absence
Fail Fast (Martin Fowler)
Structure systems to reduce severity
Hazard mitigation
- add code to check things that shouldnt be needed, but would mitigate severity of bug
- check a few important things
- figure out invariants of system
  - customer_id, patient_id
- add checks, fail fast, add alert
- scoped find hook - force ‘customers’ to be scoped to merchant (braintree)
  - can bypass with special parameter (safety)
focus on validity of data
- doublecheck calculations and allow for rerun
write checks outside of normal flow of code
- keep very simple
- alerts on num transactions (old ones), high numbers, latency
hacks at development time
safe migrations
- unsafemigrationerror (alias old method)
- add/remove
- unsafe prefix to bypass
- TODO find gem for this?
sanity specs
- doublecheck ids public_id indexes
- indexes on relations? automatic?
  - ActiveRecord.tables.indexes
- automated checks on crazy / dangerous operations

Your bright metaprogramming future - Betsy Haibel \w Optoro @betsythemuffin

not skynet or magical or perl (lol)
code that treats the program as just data
Object.send(method, *args)
- sends a message to the object
- breaks grep (hard to find cause method names are obsured)
- cyclomatic complexity - paths that can take through code
- limit scope of dynamic method calls, keep closer to the code its calling
method_missing
- need respond_to_missing
- call super (chaining)
- method_missing is slow by itself - define_method once found?
  - if you’re gunna do this, maybe predefine these instead
- consider using a different paradigm
- good for objects (OpenStruct), delegators (Delegator mixin)?
define_method
- performance at load is pretty slow - causes class / method table rebuild
- wrap in a method (define_...) so can be tested/redefined
- Put these into an anonymous module?
hooks
- normal: inherited, included, extended
- weird: method_added, method_removed, singleton_*
- dont?!
  - consider using a simple macro and using a separate object

Rails REST API versioning

Wed, 18 Sep 2013 08:39:00 -0700

There have been a few other articles regarding versioning REST APIs in Rails. Many reference this RailsCasts (#350) to set up header based versioning, and there have been a few setting up path based versioning using the ‘namespace’ feature in Rails 3 routing.

Our API was set up with path based using routing namespaces, and we moved ahead happily with v1.

namespace :v1 do
  resource :ping
end

class Api::V1::PingController ...
end

GET http://example.org/v1/ping

Recently we started working on v2 features, and started in a new namespace, looking just like v1. To make it easy on our apps, we wanted to make all the API calls against the v2 api, even on controllers that didn’t get an ‘upgrade’ into the v2 namespace.

http://example.org/v1/ping
http://example.org/v2/ping #fallback to the v1
http://example.org/v2/pong #use v2 namespace

This is a non-obvious operation. In most REST cases, redirects like explained in this StackOverflow post are not possible because you shouldn’t redirect POSTs (technically an HTTP 301 response should work, but there are few HTTP clients that respect that strict mode. If you don’t believe a 301 response to a POST should result in a new POST, read the spec carefully).

Josh Symonds talks about how existing API solutions are terrible, and really only one of the gems Symonds talks about in his post handles ‘fallback’ apis: rocket_pants. I wasn’t keen on using the whole kit of rocket_pants features, so I looked into how the ‘api’ method works. Its just a fancy wrapper around a ‘scope’ line.

Taking a cue from that, I came up with the replacement for the ‘namespace’ lines:

scope :module => 'v2', :path => ':api_version', :constraints => { :api_version => /v2/ } do
   resource :pong
end

scope :module => 'v1', :path => ':api_version', :constraints => { :api_version => /v[12]/ } do
  resource :ping
end

A few notes about the scope line:

specs/tests that test ‘route_to’ assertions will need to respect the fact that :api_version will be included in the list of route parameters
regex against paths cannot be anchored. It throws an exception at app startup time (which Passenger may hide), because those regexes are already anchored, and really you’re only working on one piece of the path at a time.
Order matters in routing - it is evaluated top-down so pay attention to the fallbacks.

Now, in the v2 scope, we can also override a given resource with a controller from the new namespace, since it will match first.

MP4Box can fix your online-hosted MP4s

Wed, 09 Jan 2013 06:56:00 -0800

I just discovered MP4Box (available in osx homebrew as well as other places). It has tools for rearranging your MP4 videos to optimize them for streaming. We just did this on all our videos, and not only do they start up faster on every device, it fixed some devices that refused to play our videos!

Our magic incantation was simple: MP4Box -hint $file

Toggle Rails Caching in RSpec Suites

Mon, 07 Jan 2013 00:20:00 -0800

Useful snippet for enabling/disabling the cache during rspec

Log example names/descriptions from rspec

Wed, 19 Dec 2012 04:42:52 -0800

This can help dig into the logs for a spec file. You can do one of these two things (both is overkill)

Local/Server synchronization with Ruby and FSEvent

Sun, 02 Oct 2011 02:12:00 -0700

A lot of the work I do is PHP/html type coding. I try to keep a local setup that is able to run all of my code without too much trouble, but eventually all that code has to be tested on something resembling the production environment, or there are certain functions that can only be performed there (say, handling NFS mounts, or attaching to databases otherwise firewalled on my local machine). In those situations, I need to be able to quickly copy my code from my local machine to the development server. I used to do this manually, but the cycle of edit-save-copy-test was really annoying. Aptana and Eclipse have some tools that help, but I don’t use those tools anymore day-to-day, and they seemed to always get messed up.

I took while to find a suitable setup for keeping files in sync like this. Somehow I came across doubledown, a ruby script using the OSX FSEvent framework. For whatever reason, I couldn’t quite make it work on my machine (YMMV), so I took the idea and searched for other uses of FSEvent out there. I came across a few rubygems wrapping FSEvent nicely, and wrote a script around that. First, you’ll probably want to set up ssh keys. This will let you rsync over ssh without having to log in every time (kind of important on this one). I don’t like the idea of having keys that don’t have a password, so I use keychain to manage my keys. In my ~/.zshrc I have the following snippet:

The random delay lets me launch more than one shell at a time (my default windowgroup in Terminal.app is has two) without conflict.

Second, you’ll want to have a way to fully-sync your directories. The following script does this with a single command, and with some options provided by gnu getopt. The biggest features are a preset source/destination (which can be appended), and skipping .svn/.hg directories. In a rush, skipping those makes a HUGE speed difference (especially when skipping svn).

Now for the actual ruby script using FSEvent. It also includes using growl to notify on synchronization events. While not required, it is nice to know when things are synched (and it lets me know the script is still running), but it can get a bit spammy (especially running svn up on a directory).

These scripts aren’t perfect, and are meant to be modified to your own needs and preferences. Its so nice not to have to worry about manually syncing the directories anymore though!

OnyxRaven

Ruby On Ales Day 2

Baby Driven Development: BDD

Thoughts

How to stop hating your tests

Thoughts

a machine state of mind

Thoughts

In the Name of Whiskey

Thoughts

fold, paper, scisors - origami cut and fold problem

Thoughts

Crystal Programming Lang

Thoughts

when good software goes bad

Thoughts

Ruby On Ales Day 1

Opensource Survival Guide

Thoughts

Including People

Thoughts

Orbits

Thoughts

Choices

Thoughts

Writing a test framework from scratch

Thoughts

Self teaching for developers

Thoughts

RubyConf 2014 - Day 3

Keynote - Social Coding Contract

@schneems - Richard Schneeman - Text distance - github.com/schneems/going_the_distance bit.ly/going_the_distance

Benchmarking Ruby - github.com/davy/benchmarking_ruby - @davystevenson

Ruby performance secrets - Alexander Dymo

REAL WORLD RUBY PERFORMANCE AT SCALE - Aaron Quint - @aq - paperless post - github/quirkey /paperlesspost

RubyConf 2014 - Day 2

Keynote - Sandi Metz - MADAM SANDI TELLS YOUR FUTURE

Fringe Ruby - 2 + CATS = 4 * CUTE: HOW MATH WORKS IN RUBY - Chris Hoffman - @yarmiganosca - Optoro

Fringe Ruby - A PARTIAL-MULTIVERSE MODEL OF TIME TRAVEL FOR DEBUGGING - Brock Wilcox

JRuby 9000 - Charles Nutter @headius & Tom Enebo @tom_enebo

Elixr

MY LITTLE C EXTENSION: LEGO ROBOTS ARE MAGIC - Brandon Hays

RubyConf 2014 - Day 1

Keynote - Yukihiro “Matz” - “Feeding the Sharks”

Advanced - I <3 Promises in Ruby - Dinshaw Gobhai - @tallfriend

Advanced - Letting Concurrency help you today - Richard Bishop - @rbondev

Future proofing your 3rd party integrations - @idlehands - Jeffery Matthias

GOING EVERGREEN - Kane Baccigalupi - @rubyghetto

Fighting Bugs with Hacks - Paul Gross - @pgr0ss

Your bright metaprogramming future - Betsy Haibel \w Optoro @betsythemuffin

Rails REST API versioning

MP4Box can fix your online-hosted MP4s

Toggle Rails Caching in RSpec Suites

Log example names/descriptions from rspec

Local/Server synchronization with Ruby and FSEvent