{"status":"success","username":"davidadepoju","page_id":11904,"firstname":"Oluwaseun David ADEPOJU","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"text\",\"header\":\"Meet Oluwaseun.......\",\"data\":[{\"localHTML\":\"<p>Oluwaseun David ADEPOJU is a Global Challenges Faculty at the African Leadership Univesity, Kigali Rwanda. Before joining the University as a member of the faculty, he was the founder and the manager of TECHmIT Africa, a Technology and Innovation Ecosystem Advocacy organization in Nigeria. He had a bachelor in Library and information science from the University of Ibadan, Nigeria. A masters in Information Science at the University of Ibadan Nigeria. A masters in Public Policy (Technology Policy) at the Korean Development Institute School of Public Policy and Management South Korea. He is currently pursuing a PhD Program in Creative Technologies at the COLAB, Auckland University of Technology, New Zealand. He was featured in the GIZ-MakeIT Africa Technology Trendscouting Report of 2018 as one of the experts working in the technology field in Africa.<\/p><pre><code><\/code><\/pre><p><br><\/p>\"}]}","{\"type\":\"video\",\"header\":\"Oluwaseun in Videos......\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/Kt8v_uqcLvM\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/vgx3MZD2KlA\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/TSto6D4s5iQ\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/CSmnq20NTHg\"}]}","{\"type\":\"list\",\"header\":\"Publications\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/3c1438db-6c74-4c8c-8a06-f856dc8658ba\/I6DqoWU30YxIslle6ocVdWHr3Pl1Bc7zAD2oisSs.png\",\"title\":\"Digital Nomads and the Changing Work-Life of Technology Entrepreneurs in Nigeria \",\"desc\":\" Peer-reviewed Paper (International Journal of Digital Society, UK). 2018\",\"altText\":\"\",\"url\":\"https:\/\/www.researchgate.net\/publication\/338218812_Digital_Nomads_and_the_Changing_Work_Life_of_Technology_Entrepreneurs_in_Nigeria\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/79986d6e-70ef-446a-b8b6-14b34eed6e9b\/XpmO4Gv0Xtv4p9UZnBIJ6SFiBfU7aMReGyxo7S1y.png\",\"title\":\"The Role of Internet Penetration on Online Opportunity Search among the youths  in Rwanda\",\"desc\":\" Peer-reviewed Paper (International Journal of Internet and Secured Transactions, UK)\",\"altText\":\"\",\"url\":\"https:\/\/www.researchgate.net\/publication\/338604736_The_Role_of_Internet_Penetration_on_Online_Opportunity_Search_among_the_Youths_in_Rwanda\"},{\"image\":\"\",\"title\":\"Tweets and Threads: Social Media Analytics of Perth and Adelaide Cities of Australia in their E-government Initiatives\",\"desc\":\" Conference Paper (2nd International Conference on Science, Technology and Innovation, Seoul South Korea)\",\"altText\":\"\",\"url\":\"https:\/\/www.researchgate.net\/publication\/340298385_Tweets_and_Threads_A_Social_Media_Analytics_of_E-government_Initiatives_in_two_Australian_Cities\"},{\"image\":\"\",\"title\":\"Technology Entrepreneurs: Surviving the Valley of Death in the Nigerian Innovation Ecosystem\",\"desc\":\"Conference Paper (1st International Conference on African Entrepreneurship and Innovation, De Montfort University, Leicester United Kingdom)\",\"altText\":\" \",\"url\":\"\"},{\"image\":\"\",\"title\":\"Korea's Digital Maturity in Electronic Government: Lessons for Developing Countries. A competition paper for K-Developedia\",\"desc\":\"K-developedia\",\"altText\":\"\",\"url\":\"https:\/\/www.researchgate.net\/publication\/340298633_Korea's_Digital_Maturity_in_Electronic_Government_Lessons_for_Developing_Countries_A_competition_paper_for_K-Developedia\"},{\"image\":\"\",\"title\":\"Is Nigeria Technologically Ready? A call to Action\",\"desc\":\"A Policy Call to Action\",\"altText\":\"\",\"url\":\"https:\/\/www.researchgate.net\/publication\/340412361_Is_Nigeria_Technologically_Ready_A_call_to_Action?_sg=Ifpu4cZ8IpHIBR9a_ZzghlDf02ZAbvAeaMuUnxwair4dFXc3gYnukhhS5VsU5YeC1FqyKbJDUsQ10SYLirbdnaLfWxrjJJWgjNqPU6j8.oF-Fq7EaoZazoDEIE_2-0J91sTjeavKe5CgozLxg7XQhNsMaJkxrmtx_r8R9o8BkB-miGwtA2h_Ges0rP-O8hw\"},{\"image\":\"\",\"title\":\"Understanding Google Adwords\",\"desc\":\"Google Business Group\",\"altText\":\"\",\"url\":\"http:\/\/ibadantechub.com\/presentation\/understanding-google-adwords\/\"},{\"image\":\"\",\"title\":\"Onboarding Industry 4.0 for Business\",\"desc\":\"Ibadan Tech Hub\",\"altText\":\"\",\"url\":\"http:\/\/ibadantechub.com\/presentation\/onboarding-industry-4-0-for-business\/\"},{\"image\":\"\",\"title\":\"How to build a thriving innovation ecosystem\",\"desc\":\"Ibadan Tech Hub\",\"altText\":\"\",\"url\":\"http:\/\/ibadantechub.com\/presentation\/how-to-build-a-thriving-innovation-ecosystem\/\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Podcast Interview with GrandHeights USA\",\"url\":\"https:\/\/ghwings.com\/s01ep02-navigating-the-in-between\/ \"},{\"title\":\"Interview with Scholapreneurs Nigeria\",\"url\":\"https:\/\/scholarpreneurs.com\/meet-oluwaseun-adepoju\/\"},{\"title\":\"Interview with dashmedia blog\",\"url\":\"http:\/\/www.dashmedia.com.ng\/2018\/03\/meet-oluwaseun-david-adepoju-technology.html?m=0 \"},{\"title\":\"Interview with beautiful soul with Nonye Blog\",\"url\":\"https:\/\/beautifulsoulswithnonye.wordpress.com\/2018\/08\/13\/oluwaseun-adepoju-i-have-always-loved-technology\/\"},{\"title\":\"Interview with the International Center for Investigative Journalism\",\"url\":\"https:\/\/www.icirnigeria.org\/tag\/oluwaseun-david-adepoju\/ \"},{\"title\":\"TEDx Talk at TEDxUI\",\"url\":\"https:\/\/drive.google.com\/open?id=1yPxDvZTTSsuX7MJn61kI2rxYTG9R-bfu \"},{\"title\":\"Radio Portfolio\",\"url\":\"https:\/\/drive.google.com\/drive\/u\/3\/folders\/1qef6Yt-khyBmZHxqRain88Jn_kJKtu6C\"},{\"title\":\"OpenCon Algeria\",\"url\":\"https:\/\/bit.ly\/34GDZfR\"},{\"title\":\"#Hekima Story: Dispose of your car\",\"url\":\"https:\/\/awatiibadan.com.ng\/hekima-dispose-of-your-car\/\"},{\"title\":\"#Hekima Story: Procrastination\",\"url\":\"https:\/\/awatiibadan.com.ng\/hekima-procrastination\/\"},{\"title\":\"#Hekima Story: Without you, I am a bicycle\",\"url\":\"https:\/\/awatiibadan.com.ng\/hekima-without-you-i-am-a-bicycle\/\"},{\"title\":\"#Hekima Story: Your first name is extra\",\"url\":\"https:\/\/awatiibadan.com.ng\/hekima-your-first-name-is-extra\/\"},{\"title\":\"#Hekima Story: You are Valid\",\"url\":\"https:\/\/awatiibadan.com.ng\/hekima-you-are-valid\/\"},{\"title\":\"GIZ Make IT Africa feature as one of the technology experts in Africa\",\"url\":\"https:\/\/konnektiv.de\/wp-content\/uploads\/2019\/08\/Tech-Trendscouting-Toolkit-2019.pdf\"},{\"title\":\"Research Gate Profile\",\"url\":\"https:\/\/www.researchgate.net\/profile\/Oluwaseun_David_Adepoju\"},{\"title\":\"FigShare Profile\",\"url\":\"https:\/\/figshare.com\/account\/home\"},{\"title\":\"ORCID Profile\",\"url\":\"https:\/\/orcid.org\/0000-0001-5304-411X\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/d51ea5c8-4131-4f25-83f7-fc6bcb76756d\/cLJQSCW9QPxJIc1hk7BSnkbxXe9kIAmQGIxgTIMI.jpeg\",\"pageTitle\":\"Oluwaseun David ADEPOJU \",\"bio\":\"I describe myself as an academic digerati, working at the intercept of academic research and prognosticating digital futures. I paint digital futures intellectually through research foresight designs. I am a technology researcher with a special interest in a digital society, technology policies, e-government and digital philosophies. \\n\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Whatsapp\",\"label\":\"whatsapp\",\"urlPrefix\":\"www.whatsapp.com\/\",\"value\":\"2348023456789\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"iamdavidadepoju\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"techmitafrica@gmail.com\"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"tabanaku3\"},{\"id\":\"LinkedIn\",\"label\":\"linkedin\",\"urlPrefix\":\"\",\"value\":\"https:\/\/www.linkedin.com\/in\/oluwaseun-david-adepoju-b8168984\/\"}],\"setTheme\":{\"selectedFont\":\"font-lively\",\"selectedColor\":\"disha-theme-green-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-07-05T13:25:37.000000Z","updated_on":"2021-11-23T03:18:36.000000Z"}