job_dollars 1.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 93c5f216180ff72d2df380c54fe76c74c39514cb
+  data.tar.gz: 2f2ca2f47c34ba02c58eba37959285ef8b8e92c0
+SHA512:
+  metadata.gz: 9945ef0043844f89ec810a371e4e746723259656746487d37bf78ce9dcd0d0aacf67630f6c5d30b5bd3e9f653c2297cb897ff6d5fb67085aacb41da4143bcf8e
+  data.tar.gz: 40662a9fa558a8aae8907f9986e55cc46c37d6a522e32985a751d70480792ff56aef7283f17265cc0dfb605b7193d042a8848b173b5e77ec7ed7ae8d0437654c

data/lib/job_dollars.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), './job_dollars/core_ext/hash.rb')
+require File.join(File.dirname(__FILE__), './job_dollars/core_ext/hash_with_indifferent_access.rb')
+require File.join(File.dirname(__FILE__), './job_dollars/estimator.rb')
+
+require 'yaml'
+
+# JobDollars is the main module to include to start using JobDollars. It automatically
+# includes the built-in Estimator module, along with some constants.
+#
+# Example (IRB):
+#
+#   irb(main):001:0> require 'job_dollars'
+#   => true
+#   irb(main):002:0> include JobDollars
+#   => Object
+#   irb(main):006:0> beginner_javagrad_rating(JOB_DATA['java-android'])
+#   => 17.541885876163494
+module JobDollars
+  DATA_YML_FILE = File.join(File.dirname(__FILE__), './job_dollars.yml')
+
+  extend Estimator
+
+  def self.included(base)
+    base.include Estimator
+  end
+
+  JOB_DATA = YAML.load(File.read(DATA_YML_FILE))
+  JAVAGRAD_IN_JOB_DOLLARS = market_work_in_job_dollars(0.0, JOB_DATA["java-swing"])
+end
+

data/lib/job_dollars.yml

@@ -0,0 +1,329 @@
+--- !map:HashWithIndifferentAccess
+
+csharp-dotnet:
+  salaries:
+    entry: >
+      $65,000+ (2686)
+      $75,000+ (2243)
+      $80,000+ (1913)
+      $90,000+ (1218)
+      $100,000+ (637)
+
+    mid: >
+      $85,000+ (1823)
+      $95,000+ (1544)
+      $105,000+ (1122)
+      $110,000+ (906)
+      $120,000+ (477)
+
+    senior: >
+      $100,000+ (610)
+      $110,000+ (482)
+      $115,000+ (363)
+      $120,000+ (280)
+      $130,000+ (142)
+
+  jobs:
+    entry: 3137
+    mid: 11974
+    senior: 3422
+
+  resumes: 128_839
+
+ruby-rails:
+  salaries:
+    entry: >
+      $75,000+ (777)
+      $90,000+ (634)
+      $100,000+ (500)
+      $105,000+ (383)
+      $115,000+ (198)
+
+    mid: >
+      $85,000+ (1823)
+      $95,000+ (1544)
+      $105,000+ (1122)
+      $110,000+ (906)
+      $120,000+ (477)
+
+    senior: >
+      $100,000+ (610)
+      $110,000+ (482)
+      $115,000+ (363)
+      $120,000+ (280)
+      $130,000+ (142)
+
+  jobs:
+    entry: 908
+    mid: 2088
+    senior: 718
+
+  resumes: 20_269
+
+javascript-redux:
+  salaries:
+    entry: >
+      $80,000+ (64)
+      $95,000+ (48)
+      $100,000+ (38)
+      $105,000+ (27)
+      $110,000+ (21)
+
+    mid: >
+      $90,000+ (127)
+      $100,000+ (106)
+      $105,000+ (83)
+      $110,000+ (64)
+      $120,000+ (29)
+
+    senior: >
+      $100,000+ (43)
+      $105,000+ (38)
+      $110,000+ (28)
+      $115,000+ (22)
+      $130,000+ (8)
+
+  jobs:
+    entry: 71
+    mid: 144
+    senior: 47
+
+  resumes: 448
+
+java-swing:
+  salaries:
+    entry: >
+      $70,000+ (61)
+      $75,000+ (56)
+      $80,000+ (43)
+      $90,000+ (29)
+      $105,000+ (12)
+
+    mid: >
+      $85,000+ (249)
+      $90,000+ (223)
+      $100,000+ (148)
+      $105,000+ (117)
+      $115,000+ (50)
+
+    senior: >
+      $85,000+ (126)
+      $95,000+ (99)
+      $105,000+ (73)
+      $110,000+ (57)
+      $120,000+ (27)
+
+  jobs:
+    entry: 71
+    mid: 292
+    senior: 136
+
+  resumes: 23_648
+
+java-android:
+  salaries:
+    entry: >
+      $70,000+ (977)
+      $85,000+ (785)
+      $95,000+ (613)
+      $105,000+ (398)
+      $115,000+ (235)
+
+    mid: >
+      $85,000+ (2461)
+      $95,000+ (2032)
+      $105,000+ (1451)
+      $110,000+ (1176)
+      $120,000+ (646)
+
+    senior: >
+      $90,000+ (896)
+      $100,000+ (758)
+      $110,000+ (563)
+      $120,000+ (343)
+      $130,000+ (181)
+
+  jobs:
+    entry: 1_142
+    mid: 2_896
+    senior: 1_002
+
+  resumes: 65_373
+
+java-j2ee:
+  salaries:
+    entry: >
+      $70,000+ (764)
+      $75,000+ (688)
+      $85,000+ (487)
+      $95,000+ (322)
+      $105,000+ (176)
+
+    mid: >
+      $80,000+ (3173)
+      $90,000+ (2557)
+      $95,000+ (2142)
+      $100,000+ (1697)
+      $110,000+ (845)
+
+    senior: >
+      $90,000+ (1805)
+      $100,000+ (1412)
+      $105,000+ (1166)
+      $110,000+ (935)
+      $120,000+ (510)
+
+  jobs:
+    entry: 910
+    mid: 3_692
+    senior: 2_087
+
+  resumes: 92_525
+
+swift-ios:
+  salaries:
+    entry: >
+      $65,000+ (403)
+      $85,000+ (340)
+      $95,000+ (282)
+      $105,000+ (196)
+      $115,000+ (102)
+
+    mid: >
+      $85,000+ (837)
+      $95,000+ (699)
+      $105,000+ (502)
+      $110,000+ (417)
+      $120,000+ (218)
+
+    senior: >
+      $95,000+ (235)
+      $105,000+ (189)
+      $110,000+ (159)
+      $120,000+ (98)
+      $130,000+ (47)
+
+  jobs:
+    entry: 471
+    mid: 984
+    senior: 267
+
+  resumes: 6_169
+
+javascript-jquery:
+  salaries:
+    entry: >
+      $60,000+ (2249)
+      $75,000+ (1821)
+      $85,000+ (1404)
+      $95,000+ (903)
+      $105,000+ (453)
+
+    mid: >
+      $75,000+ (8387)
+      $85,000+ (6890)
+      $90,000+ (5850)
+      $100,000+ (3551)
+      $110,000+ (1685)
+
+    senior: >
+      $90,000+ (2352)
+      $95,000+ (2049)
+      $100,000+ (1701)
+      $105,000+ (1257)
+      $115,000+ (604)
+
+  jobs:
+    entry: 2_571
+    mid: 9_641
+    senior: 2_803
+
+  resumes: 123_148
+
+php:
+  salaries:
+    entry: >
+      $45,000+ (4548)
+      $60,000+ (3761)
+      $75,000+ (2779)
+      $85,000+ (2058)
+      $100,000+ (1100)
+
+    mid: >
+      $65,000+ (9836)
+      $80,000+ (7749)
+      $90,000+ (5693)
+      $95,000+ (4595)
+      $105,000+ (2631)
+
+    senior: >
+      $85,000+ (2511)
+      $95,000+ (2116)
+      $105,000+ (1478)
+      $110,000+ (1171)
+      $120,000+ (629)
+
+  jobs:
+    entry: 5_458
+    mid: 11_397
+    senior: 2_892
+
+  resumes: 184_970
+
+javascript-react:
+  salaries:
+    entry:
+      $80,000+ (622)
+      $90,000+ (531)
+      $100,000+ (380)
+      $110,000+ (249)
+      $115,000+ (174)
+
+    mid:
+      $90,000+ (1832)
+      $95,000+ (1601)
+      $100,000+ (1370)
+      $110,000+ (825)
+      $120,000+ (426)
+
+    senior:
+      $95,000+ (658)
+      $105,000+ (505)
+      $110,000+ (426)
+      $115,000+ (323)
+      $125,000+ (158)
+  jobs:
+    entry: 723
+    mid: 2_192
+    senior: 727
+  resumes: 4_409
+
+javascript-angular:
+  salaries:
+    entry:
+      $80,000+ (1233)
+      $90,000+ (1029)
+      $95,000+ (848)
+      $105,000+ (502)
+      $115,000+ (275)
+
+    mid:
+      $85,000+ (4146)
+      $95,000+ (3285)
+      $100,000+ (2704)
+      $105,000+ (2049)
+      $115,000+ (1074)
+
+    senior:
+      $95,000+ (1435)
+      $100,000+ (1269)
+      $105,000+ (1010)
+      $115,000+ (568)
+      $125,000+ (289)
+
+  jobs:
+    entry: 1_453
+    mid: 4_725
+    senior: 1_641
+
+  resumes: 27_324

data/lib/job_dollars/core_ext/array.rb

@@ -0,0 +1,22 @@
+class Array
+# File activesupport/lib/active_support/core_ext/array/grouping.rb, line 20
+  def in_groups_of(number, fill_with = nil)
+    if number.to_i <= 0
+      raise ArgumentError,
+        "Group size must be a positive integer, was #{number.inspect}"
+    end
+
+    if fill_with == false
+      collection = self
+    else
+      padding = (number - size % number) % number
+      collection = dup.concat(Array.new(padding, fill_with))
+    end
+
+    if block_given?
+      collection.each_slice(number) { |slice| yield(slice) }
+    else
+      collection.each_slice(number).to_a
+    end
+  end
+end

data/lib/job_dollars/core_ext/hash.rb

@@ -0,0 +1,9 @@
+
+class Hash
+
+  def with_indifferent_access
+    ActiveSupport::HashWithIndifferentAccess.new(self)
+  end
+
+  alias nested_under_indifferent_access with_indifferent_access
+end

data/lib/job_dollars/core_ext/hash_with_indifferent_access.rb

@@ -0,0 +1,174 @@
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/reverse_merge'
+
+module ActiveSupport
+  class HashWithIndifferentAccess < Hash
+    def extractable_options?
+      true
+    end
+
+    def with_indifferent_access
+      dup
+    end
+
+    def nested_under_indifferent_access
+      self
+    end
+
+    def initialize(constructor = {})
+      if constructor.respond_to?(:to_hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      hash = hash.to_hash
+      new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+        new_hash.default_proc = hash.default_proc if hash.default_proc
+      end
+    end
+
+    def self.[](*args)
+      new.merge!(Hash[*args])
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value, for: :assignment))
+    end
+
+    alias_method :store, :[]=
+
+    def update(other_hash)
+      if other_hash.is_a? HashWithIndifferentAccess
+        super(other_hash)
+      else
+        other_hash.to_hash.each_pair do |key, value|
+          if block_given? && key?(key)
+            value = yield(convert_key(key), self[key], value)
+          end
+          regular_writer(convert_key(key), convert_value(value))
+        end
+        self
+      end
+    end
+
+    alias_method :merge!, :update
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    def values_at(*indices)
+      indices.collect { |key| self[convert_key(key)] }
+    end
+
+    def dup
+      self.class.new(self).tap do |new_hash|
+        set_defaults(new_hash)
+      end
+    end
+
+    def merge(hash, &block)
+      self.dup.update(hash, &block)
+    end
+
+    def reverse_merge(other_hash)
+      super(self.class.new_from_hash_copying_default(other_hash))
+    end
+
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    def replace(other_hash)
+      super(self.class.new_from_hash_copying_default(other_hash))
+    end
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def deep_stringify_keys!; self end
+    def stringify_keys; dup end
+    def deep_stringify_keys; dup end
+    undef :symbolize_keys!
+    undef :deep_symbolize_keys!
+    def symbolize_keys; to_hash.symbolize_keys! end
+    def deep_symbolize_keys; to_hash.deep_symbolize_keys! end
+    def to_options!; self end
+
+    def select(*args, &block)
+      dup.tap { |hash| hash.select!(*args, &block) }
+    end
+
+    def reject(*args, &block)
+      dup.tap { |hash| hash.reject!(*args, &block) }
+    end
+
+    def to_hash
+      _new_hash = Hash.new
+      set_defaults(_new_hash)
+
+      each do |key, value|
+        _new_hash[key] = convert_value(value, for: :to_hash)
+      end
+      _new_hash
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value, options = {})
+        if value.is_a? Hash
+          if options[:for] == :to_hash
+            value.to_hash
+          else
+            value.nested_under_indifferent_access
+          end
+        elsif value.is_a?(Array)
+          if options[:for] != :assignment || value.frozen?
+            value = value.dup
+          end
+          value.map! { |e| convert_value(e, options) }
+        else
+          value
+        end
+      end
+
+      def set_defaults(target)
+        if default_proc
+          target.default_proc = default_proc.dup
+        else
+          target.default = default
+        end
+      end
+  end
+end
+HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
+  

data/lib/job_dollars/estimator.rb

@@ -0,0 +1,184 @@
+require File.join(File.dirname(__FILE__), './core_ext/array.rb')
+
+module JobDollars
+  # This module contains the estimation code.
+  module Estimator
+    # Estimate value of a developer resume item.
+    #
+    # @param  y (Fixnum) number of years
+    # @param  hash (HashWithIndifferentAccess) job data for the chosen skill,
+    #         shaped like the top-level values in langval.yml
+    # @return (Float) Value of resume item in dollars.
+    def value_of_resume_item_in_dollars(y, hash)
+      resu = hash[:resumes]
+      sala = crunch_salaries(hash)
+
+      chance = {
+        entry: chance_of_getting_job(y, resu, :entry),
+        mid: chance_of_getting_job(y, resu, :mid),
+        senior: chance_of_getting_job(y, resu, :senior)
+      }
+
+      ((chance[:entry] * sala[:entry]) +
+       (chance[:mid] * sala[:mid]) +
+       (chance[:senior] * sala[:senior])) / 3.0
+    end
+
+    # Estimate the work the job market does for a candidate with a certain
+    # number of years of experience in a given skill.
+    #
+    # @param  y (Fixnum) number of years
+    # @param  hash (HashWithIndifferentAccess) job data for the chosen skill,
+    #         shaped like the top-level values in langval.yml
+    # @return (Float) Market work estimate in job-dollars.
+    def market_work_in_job_dollars(y, hash)
+      candidate_type = case
+                       when y >= 5
+                         :senior
+                       when y >= 3 && y < 5
+                         :mid
+                       when y < 3
+                         :entry
+                       end
+
+      value_of_resume_item_in_dollars(y, hash) * hash[:jobs][candidate_type]
+    end
+
+    # Estimate the work the job market does for a candidate with a certain
+    # number of years of experience in a given skill, in Javagrads.
+    #
+    # @param  y (Fixnum) number of years
+    # @param  hash (HashWithIndifferentAccess) job data for the chosen skill,
+    #         shaped like the top-level values in langval.yml
+    # @return (Float) Market work estimate in Javagrads.
+    def market_work_in_javagrads(y, hash)
+      market_work_in_job_dollars(y, hash) / JAVAGRAD_IN_JOB_DOLLARS
+    end
+
+    # Calculate the number of Javagrads of work the job market does for beginners
+    # (zero years of experience) with this skill.
+    #
+    # @param  hash (HashWithIndifferentAccess) job data for the chosen skill,
+    #         shaped like the top-level values in langval.yml
+    # @return (Float) Beginner rating in Javagrads.
+    def beginner_javagrad_rating(hash)
+      market_work_in_javagrads(0.0, hash)
+    end
+
+    # Get the average salary for jobs returned from an Indeed.com search,
+    # based on refinements sidebar text with facet totals.
+    #
+    # @param  salatext (String) refinements text
+    # @param  total (Fixnum) total number of results
+    # @return (Float) Average salary in dollars
+    def average_salary_from_indeed_facets(salatext, total)
+      salaries = salatext.split(/\s+/).in_groups_of(2).map { |r| r.map { |i| i.gsub(/\D/, '').to_f }}
+
+      salaries = [[salaries[0][0], total.to_f]] + salaries
+
+      salaries = salaries.map.with_index do |salary, idx|
+        if idx == 0
+          amt, count = *salary
+          [amt, count - salaries[1][1]]
+        elsif idx == salaries.size-1
+          salary
+        else
+          amt, count = *salary
+          [(amt+salaries[idx+1][0])/2, count-salaries[idx+1][1]]
+        end
+      end
+
+      salaries = salaries.map do |amt, count|
+        amt * count
+      end
+
+      salaries.inject(&:+) / total
+    end
+
+    NORMAL_DISTRIBUTION = {
+      1 => [1.0],
+      2 => [0.5,0.5],
+      3 => [0.0918,0.82,0.0918],
+      4 => [0.0228,0.48,0.48,0.0228],
+      5 => [0.0082,0.21,0.58,0.21,0.0082],
+      6 => [0.0038,0.09,0.41,0.41,0.09,0.0038],
+      7 => [0.0021,0.04,0.24,0.43,0.24,0.04,0.0021],
+      8 => [0.0013,0.02,0.14,0.34,0.34,0.14,0.02,0.0013],
+      9 => [0.0009,0.01,0.09,0.24,0.34,0.24,0.09,0.01,0.0009],
+      10 => [0.0007,0.01,0.04,0.16,0.29,0.29,0.16,0.04,0.01,0.0007],
+      11 => [0.0005,0.01,0.03,0.1,0.22,0.28,0.22,0.1,0.03,0.01,0.0005]
+    }
+
+    # Given the total number of resumes, model the probability
+    # distribution that various numbers of resumes will be selected.
+    #
+    # @param  total_resumes (Fixnum) Total number of resumes.
+    # @return (Hash<Fixnum, Float>) Probabilities keyed to the number
+    #         of resumes selected.
+    def applicants_per_job_distribution(total_resumes)
+      max = (Math.log(total_resumes) / 1.5).to_i + 1
+
+      dist = (1..max).to_a.map do |num|
+        [num, NORMAL_DISTRIBUTION[max][num-1]]
+      end
+
+      Hash[dist]
+    end
+
+    # Compute the chance a candidate will get a job, given the years
+    # of experience, total number of resumes, and the candidate type
+    #
+    # @param  years (Float) candidate years of experience
+    # @param  total_resumes (Fixnum) total resumes
+    # @param  type (Symbol) in [:entry, :mid, :senior]
+    # @return (Float) Chance the candidate will get a job
+    def chance_of_getting_job(years, total_resumes, type = :senior)
+      year_range = case
+                   when type == :senior
+                     [5.0, 10.0]
+                   when type == :mid
+                     [3.0, 5.0]
+                   when type == :entry
+                     [0.0, 3.0]
+                   end
+
+      strength = [((years.to_f - year_range[0]) / (year_range[1] - year_range[0])), 1.0].min
+
+      return 0.0 if strength < 0
+
+      dist = applicants_per_job_distribution(total_resumes)
+      dist = dist.map do |resumes, c|
+        other_resumes = resumes - 1
+
+        # probability of getting the job
+        c * (strength ** other_resumes)
+      end
+
+      dist.inject(&:+)
+    end
+
+    # Get the salary distribution for a skill.
+    #
+    # @param  hash (Hash) A hash of job data shaped like the top-level values
+    #         in langval.yml
+    # @return (Hash<Symbol, Float>) {entry: Float, mid: Float, senior: Float}
+    def crunch_salaries(hash)
+      {
+        entry: average_salary_from_indeed_facets(hash["salaries"]["entry"], hash["jobs"]["entry"]),
+        mid: average_salary_from_indeed_facets(hash["salaries"]["mid"], hash["jobs"]["mid"]),
+        senior: average_salary_from_indeed_facets(hash["salaries"]["senior"], hash["jobs"]["senior"])
+      }
+    end
+
+    # Convert job-dollars to Javagrads.
+    #
+    # @param  job_dollars (Float) Job-dollars.
+    # @return (Float) Javagrads, precision-1.
+    def to_javagrads(job_dollars)
+      (job_dollars / JAVAGRAD).to_f(1)
+    end
+
+  end
+end
+
+

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: job_dollars
+version: !ruby/object:Gem::Version
+  version: 1.0.5
+platform: ruby
+authors:
+- Tyler Boyd
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-07 00:00:00.000000000 Z
+dependencies: []
+description: A job dollar is an objective measure of the strength of the job market
+  for entry-level workers using a given programming language and framework. It is
+  a composite measure of work, like kilowatt-hours or Joules, and it measures how
+  much work the market has done for you.
+email: tboyd47@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/job_dollars.rb
+- lib/job_dollars.yml
+- lib/job_dollars/core_ext/array.rb
+- lib/job_dollars/core_ext/hash.rb
+- lib/job_dollars/core_ext/hash_with_indifferent_access.rb
+- lib/job_dollars/estimator.rb
+homepage: https://www.github.com/tb0yd/job_dollars
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "-x"
+- lib/job_dollars/core_ext/*
+- "-m"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: An economic measure of the value of a programming language and framework.
+test_files: []