{"status":"success","username":"stemgirlspictureperfect","page_id":22232,"firstname":"STEM Girls Picture Perfect","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/f8d2a45e-4b2e-4c41-9ebe-2582be60aae0\/6yOEwgcdtfVR3IGDIiTr6P2I4NxrM5euvfSxhH4Q.png\",\"title\":\"Stem Girls' Picture Perfect\",\"altText\":\"Stem Girls' Picture Perfect\",\"url\":\"\"}]}","{\"type\":\"text\",\"header\":\"About the Stem Girls' Picture Perfect\",\"data\":[{\"localHTML\":\"<p>STEM is important because it is subtly woven into every part of our lives. Science is everywhere in the world around us. Technology is continuously expanding into every aspect of our lives. Engineering is the basic design of roads and bridges but also tackles the challenges of changing global weather and environmentally-friendly changes to our home. Mathematics is in every occupation, every activity we do in our lives. By exposing students to STEM and giving them opportunities to explore STEM-related concepts, they will develop a passion for it and hopefully pursue a job in a STEM field.<\/p><p><\/p>\"}]}","{\"type\":\"text\",\"header\":\"\",\"data\":[{\"localHTML\":\"<p><strong>The Problem<\/strong><\/p><p>Though there have been strides in bridging gender inequality, gender gaps in STEM education and jobs persist.<\/p><p>There are only 28% of women in STEM fields as opposed to 72% of men.<\/p><p>One explanation for the gender differences in STEM participation may lie with formative ideas about who a mathematician or scientist is.<\/p><p><strong>Our Approach<\/strong><\/p><p>In building a STEM Identity, this project seeks to add images of female mathematicians or scientists <strong><em>worldwide<\/em><\/strong> in a coloring book that summarizes women\u2019s achievements in these subjects. This dares girls to dream, shift perceptions, bridges the inequality gap, and allows girls to contribute to shaping the world.<\/p><p>There will be three releases of the book each year scheduled for each quarter.<\/p><p><\/p>\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/ca9130b6-ae8c-48a1-99ee-d07965deb4dc\/2eafjTOx9PyONIZQT0c9irE7eNQFeX27udUkJjvv.png\",\"title\":\"Target Audience\",\"altText\":\"Target Audience\",\"url\":\"\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Nominate a female in STEM\",\"url\":\"https:\/\/bit.ly\/STEMBookNominateAFemale\"},{\"title\":\"Support\/Partner with Us\",\"url\":\"https:\/\/bit.ly\/37ksDR8\"},{\"title\":\"Be the first to get our book\",\"url\":\"https:\/\/bit.ly\/GetSTEMGirlsBook\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/a4776908-ebc3-41f2-b8d3-c9eebb4241cb\/r5WNkZH2GNf03xuCOemYSwKeUysAD09qDlRkviUZ.png\",\"title\":\"Creating impact with STEM Girls' Picture Perfect\",\"altText\":\"Creating impact with STEM Girls' Picture Perfect\",\"url\":\"\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Reach out\",\"url\":\"http:\/\/stemgirlspp@gmail.com\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/68298c02-7fa6-40fa-896d-f2fe08bc13fe\/QS7HuUoJdX99dDgde3KnvpPP1sq2MyhL7GzpVDSq.png\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/acf8124b-b705-46fa-bd66-6e1adda377e8\/AyzARYJbajmoLFdAx5wSWpWLegW0FMNVNBeHcQ4b.jpeg\",\"pageTitle\":\"STEM Girls Picture Perfect\",\"bio\":\"A book-based approach to mentorship aimed at building a STEM Identity for girls through a color book. The book summarizes women\u2019s work in STEM, dares girls to dream, shift perceptions, bridges the inequality gap, and allows girls to contribute to shaping the world through STEM.\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"LinkedIn\",\"label\":\"linkedin\",\"urlPrefix\":\"\",\"value\":\"https:\/\/www.linkedin.com\/company\/stem-girls-picture-perfect-project\/\"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"stemgirlbooks\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"stemgirlspictureperfect\"},{\"id\":\"Facebook\",\"label\":\"facebook\",\"urlPrefix\":\"www.facebook.com\/\",\"value\":\"stemgirlspictureperfect\"}],\"setTheme\":{\"selectedFont\":\"font-modern\",\"selectedColor\":\"disha-theme-pink-gradient\",\"selectedBorder\":\"border-default\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-light\",\"selectedBrand\":\"brandEnabled\"},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"}}","currency":null,"country":null,"industry":null,"is_discoverable":1,"is_payment_on":1,"has_products":false,"locale":"en","rave_islive":0,"rave_keys":"","created_on":"2020-11-15T01:05:51.000000Z","updated_on":"2021-11-28T02:36:49.000000Z"}