Performmance Immo recrute un développeur 'FrontEnd' pour faire du React.js

FrontDev.scala

package fr.perfimmo.hiring

// Le code compile ^^
object FrontDev {
  val whoWeAre = PerformmanceImmo(
    companyName = "performmance immo",

    website = "http://www.performance-immo.com",

    areaField = "edition logiciel / administration de bien",

    companyVision = """
      Perfommance immo est une plateforme en ligne permettant de réunir les intervenants de 
      l'administration de biens immobiliers (gestionnaires, propriétaires, locataires).

      Nous construisons une équipe de gens passionnés, tous acteurs de la réalisation de 
      ce projet, visant l'excellence technique et l'amélioration continue dans la 
      réalisation de leur travail.

      Pour ce faire, nous sommes organisés sans hiérarchie, nos décisions se prennent 
      ensemble, collectivement, au consentement.
      Nous expérimentons des outils d'organisation tel que eXtrême programming, Kanban, 
      Lean Startup et nous sommes motivés autant à innover d'un point de vue technique 
      qu'organisationnel.
      """,
  
  location = "Paris / IDF",

  team = List(
    Teammate("Nicolas Marx", "CEO fondateur de Performmance-immo"),
    Teammate("Ugo Bourdon", "CTO plutôt spécialisé dans les technos 'BackEnd'")
  ),

  methods = XP :: KANBAN :: LEAN_STARTUP :: Nil,

  backEndTechnoz = SCALA :: PLAY_FRAMEWORK :: MONGO_DB :: GET_EVENTSTORE :: ELASTIC_SEARCH :: Nil,

  frontEndTechnoz = PLAY_TEMPLATE(WE_DONT_LIKE_IT) :: ReactJs(WE_LIKE_IT) :: Nil,

  archi = GIT :: EVENTSOURCING :: CQRS :: REST :: DDD :: Nil,

  programmingStyleWeLove = FUNCTIONAL_PROGRAMMING :: Nil
)

val whoWeAreLookingFor = Dev(
  experience = Experimenté,

  specialité = FrontEnd,

  contrat = UpToYou :: Nil,

  blabla = """
    Nous recherchons un(une) développeur(se) FrontEnd, expérimenté(e) (au moins 3-5 ans d'expérience), 
    qui connaît React.js.
    Notre 'Front' est pour l'instant codé avec des 'template playframework' 
    (et nous n'aimons vraiment pas ça).
    L'objectif est de refondre le 'Front' en 'Single Page App' avec la techno React.js, interfacé 
    avec le 'BackEnd' via des API REST.

    Ce(Cette) développeur(se), nous le souhaitons passionné(e), acharné(e) du 'clean code', 
    des bonnes pratiques du web et du code.
    Nous attendons d'elle(lui), qu'elle(il) soit force de proposition, moteur dans les 
    décisions concernant son domaine de spécialité, mais aussi qu'elle(il) s'implique 
    dans toutes les décisions de l'équipe de développement 
    (et il y a beacoup de décisions à prendre).

    Nous sommes ouvert aux canditats(tes) Freelance (prestation) ou CDI.
  """
)

  def contactUs(contacts: List[String] = 
      "[email protected]"  :: 
      "@ugobourdon (twitter)"  :: 
      "en commentaire du gist" :: Nil) = {
        // objet du mail : [Performmance Immo] candidat(e) au poste de dévelopeur(se) Front|React.js
        ???
      }
}

hiring.scala

package fr.perfimmo

package object hiring {
	case class PerformmanceImmo(companyName: String,
	                            website: String,
	                            areaField: String,
	                            companyVision: String,
	                            location: String,
	                            team: List[Teammate],
	                            methods: List[Method],
	                            backEndTechnoz: List[BackEndTechno],
	                            frontEndTechnoz: List[FrontEndTechno],
	                            archi: List[ArchiComponent],
	                            programmingStyleWeLove: List[ProgrammingStyle])

	case class Teammate(name: String, specialty: String)


	case class Dev(experience: XP,
	               specialité: Spe,
	               contrat: List[Contract],
	               blabla: String)

	sealed trait Spe
	case object FrontEnd extends Spe
	case object BackEnd extends Spe

	sealed trait XP
	case object Experimenté extends XP

	sealed trait Contract
	case object CDI extends Contract
	case object Freelance extends Contract
	case object Presta extends Contract
	case object UpToYou extends Contract

	sealed trait Method
	case object XP extends Method
	case object KANBAN extends Method
	case object LEAN_STARTUP extends Method

	sealed trait BackEndTechno
	case object SCALA extends BackEndTechno
	case object PLAY_FRAMEWORK extends BackEndTechno
	case object MONGO_DB extends BackEndTechno
	case object GET_EVENTSTORE extends BackEndTechno
	case object ELASTIC_SEARCH extends BackEndTechno

	sealed trait FrontEndTechno {
		def likeIt: DoWeLikeIt
	}
	case class PLAY_TEMPLATE(likeIt: DoWeLikeIt) extends FrontEndTechno
	case class ReactJs(likeIt: DoWeLikeIt) extends FrontEndTechno

	sealed trait DoWeLikeIt
	case object WE_DONT_LIKE_IT extends DoWeLikeIt
	case object WE_LIKE_IT extends DoWeLikeIt

	sealed trait ArchiComponent
	case object GIT extends ArchiComponent
	case object EVENTSOURCING extends ArchiComponent
	case object CQRS extends ArchiComponent
	case object REST extends ArchiComponent
	case object DDD extends ArchiComponent

	sealed trait ProgrammingStyle
	case object FUNCTIONAL_PROGRAMMING extends ProgrammingStyle
}