Media labs
Media Innovation Mapping research seeks to understand innovation and the organisational structures that exist with news publishers, content producers, research institutions and clusters and technology providers.
It is a collaboration between the the World Association of Newspapers and News Publishers’ Global Alliance for Media Innovation, the Media Innovation Studio at UCLan, Ubilab at PUCRS university in Brazil, Norway’s NxtMedia innovation cluster and Stibo Accelerator based in Denmark.
The project plans to ‘map’ innovation labs, clusters and a selection of projects globally to establish insights into a number of factors. These include how the media labs are structured, and why they were created, what type of methods they use to innovate, their products and services and stories of their successes and failures.
Want to tell us about your Media Lab? Or to talk to us about the innovation process in your company?
Contact us
{"map_options":{"center_lat":"48.856614","center_lng":"2.3522219","zoom":2,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":false,"center_circle_fillcolor":"#8CAEF2","center_circle_fillopacity":".5","center_circle_strokecolor":"#8CAEF2","center_circle_strokeopacity":".5","center_circle_radius":"5","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https://media-innovation.news/wp-content/plugins/wp-google-map-gold/assets/images//default_marker.png","center_circle_strokeweight":"1","draggable":true,"gesture":"auto","marker_default_icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png","infowindow_setting":"<div class=\"fc-item-box fc-itemcontent-padding \">\n<div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}</span></div>\n<div class=\"fc-item-content fc-item-body-text-color\">\n<div class=\"fc-item-featured fc-left fc-item-top_space\">\n               {marker_image}\n            </div>\n<p>           {marker_message}\n    </p></div>\n<address class=\"fc-text\">{marker_address}</address>\n</div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    {post_featured_image}\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">{post_categories}</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            {post_excerpt}\r\n        </div>\r\n<a href=\"{post_link}\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","infowindow_skin":{"name":"default","type":"infowindow","sourcecode":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n\t<div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}</span></div> \r\n\t<div class=\"fc-item-content fc-item-body-text-color\">\r\n            <div class=\"fc-item-featured fc-left fc-item-top_space\">\r\n               {marker_image}\r\n            </div>\r\n           {marker_message}\r\n    </div>\r\n    <address class=\"fc-text\">{marker_address}</address>\r\n</div>\r\n"},"infowindow_post_skin":{"name":"udine","type":"post","sourcecode":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    {post_featured_image}\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">{post_categories}</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            {post_excerpt}\r\n        </div>\r\n<a href=\"{post_link}\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":true,"default_infowindow_open":false,"infowindow_open_event":"click","listing_infowindow_open_event":"click","is_mobile":false,"infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":false,"search_control":true,"zoom_control":true,"map_type_control":false,"street_view_control":false,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":10,"url_filters":false,"doubleclickzoom":true,"current_post_only":false,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"700"},"places":[{"source":"post","title":"What is WAN-IFRA\u2019s Data Science Expert Group?","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"What is WAN-IFRA\u2019s Data Science Expert Group?\" width=\"300\" height=\"170\" src=\"https://media-innovation.news/wp-content/uploads/2023/11/data-Science-Day-Paris-1536x871-1-300x170.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Data Exploration, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">What is WAN-IFRA\u2019s Data Science Expert Group?</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            WAN-IFRA launched the Data Science Expert Group intending to arm practitioners with insights, feedback, and tools to grow audiences, deepen user engagement, and optimise reader revenues.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/what-is-wan-ifras-data-science-expert-group/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"WAN-IFRA launched the Data Science Expert Group intending to arm practitioners with insights, feedback, and tools to grow audiences, deepen user engagement, and optimise reader revenues.","address":"Paris, France","location":{"lat":"48.856614","city":"Paris","state":"\u00cele-de-France","country":"France","lng":"2.3522219","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/what-is-wan-ifras-data-science-expert-group/","zoom":2,"extra_fields":{"post_excerpt":"WAN-IFRA launched the Data Science Expert Group intending to arm practitioners with insights, feedback, and tools to grow audiences, deepen user engagement, and optimise reader revenues.","post_content":"[vc_row][vc_column width=\"1/4\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1>What is WAN-IFRA\u2019s Data Science Expert Group?</h1>\r\n<h3>Convinced that data would be a breakthrough tool in newsrooms and the journalism industry, WAN-IFRA CEO, Vincent Peyregne launched the Data Science Expert Group in 2022 intending to arm practitioners with insights, feedback, and tools built around the priorities of newsrooms to grow audiences, deepen user engagement, and optimise reader revenues.</h3>\r\n&nbsp;\r\n\r\nWith over 300 members located worldwide and working within different media organisations, this group connects an international community of experts (ranging from editorial staff to data scientists, data analysts and data engineers) who share resources, experiences, stories, tools, and ways of addressing recurring problems.\u200b\r\n\r\n&nbsp;\r\n<blockquote>Peyregne said: <em>\u201cThe issue of readers engagement is a subject that has always fascinated me. When I created the Data Science Expert Group, the question I had in mind was to know if media companies were serving their readers correctly?\"</em></blockquote>\r\n&nbsp;\r\n\r\nOne of the most important issues is of course, improving and securing reader retention for a news media company. One way to do this is of course to study reader trends, evolutions, and behaviors in order to produce better suited or \u201cpersonnalised\u201d articles. More specifically, after collecting raw data on how readers engage with their content, analysts will work in partnership with the editorial staff in the newsroom to make assumptions and decisions to guide them in the production of content.\r\n\r\n&nbsp;\r\n<blockquote>Sascha Schmid, Head of Data in the Swiss media \u201cBlick\u201d and active member of the group explained: <em>\u201cstudying data is a great way to get to know our users/customers and especially their needs and how we can satisfy those needs.\u201d</em></blockquote>\r\n&nbsp;\r\n<blockquote>Another member, Cl\u00edona Mooney, Subscriptions and Reader Insights Director at\u00a0The Irish Times added: <em>\u201cThe use of insights derived from data has become a crucial enabler in our newsroom, helping our content to reach the right audience in the right format, at the right time and on the right platform. Analytics propels our excellent journalism to deliver strong results.\u201d</em></blockquote>\r\n&nbsp;\r\n\r\nMore generally, it is unanimously recognized that the studying of data has been helpful in giving the industry a positive push forward.\r\n\r\n&nbsp;\r\n\r\nConcretely, the group aims to connect people with a common interest (via regular in-person meetings, online forums or conference calls) to help each other with their work in their respective companies, to help members improve the way they are working through the integration of data.\r\n<blockquote><em>\u201cThe group gave me useful contacts to exchange experiences and whenever I receive a slack alert I go to read it ! The face-to-face meetings are especially helpful for both getting information and networking.\u201d</em> Said Trui Lanckriet, Group Data &amp; Insights Director at Mediahuis.</blockquote>\r\n&nbsp;\r\n\r\nBetween 2010 and 2015, the journalism industry had been mainly focused on acquiring digital subscribers due to the lack of advertising revenue. <em>\"To get new subscribers, you need to first know your own readership; you also need to have good retention and acquisition tactics,\"</em> Peyregne said. <em>\u201cTherefore, many media companies and newspapers equipped themselves with data scientists/specialists to respond to readers' demands.\u201d</em>\r\n\r\n&nbsp;\r\n\r\nAt the last <a href=\"https://wan-ifra.org/events/data-science-day-2023/\">WAN-IFRA Data Science Day in Vienna</a>, which took place on the 25th of April 2023, every group member was invited to Vienna for an in-person meeting. Schmid highlights the importance of these sessions: <em>\u201cThe data Science Days are inspiring and give the opportunity to discuss \u00a0with like-minded people who have similar profiles, interests and challenges. This is very useful because there are not many people like us with this very specific job.\u201c</em>\r\n\r\n&nbsp;\r\n\r\nExperts in this group span specialists in machine learning, who use artificial intelligence or algorithms to enable personalization, data engineers and chief data officers. The data group is gaining quick uptake with an average weekly registration rate of five to ten new members. If you are a data scientist working in the media industry, this group will considerably help you for the development of your data department and your research.\r\n\r\n&nbsp;\r\n\r\nTo find out more and join the group: <a href=\"https://wan-ifra.org/datascience/\">https://wan-ifra.org/datascience/</a>\r\n\r\nThe next <a href=\"https://wan-ifra.org/events/data-science-day-2024/\">Data Science Day</a> will be on 22 February 2024 in Prague, Czech Republic.\r\n\r\nWritten by Jerry-morel Takou-nguelo, Stephen Fozard and John Mills.\r\n\r\n&nbsp;\r\n\r\n[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"What is WAN-IFRA\u2019s Data Science Expert Group?","post_link":"https://media-innovation.news/media-lab/what-is-wan-ifras-data-science-expert-group/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"What is WAN-IFRA\u2019s Data Science Expert Group?\" width=\"300\" height=\"170\" src=\"https://media-innovation.news/wp-content/uploads/2023/11/data-Science-Day-Paris-1536x871-1-300x170.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Data Exploration, Media labs","post_tags":"data, data science","%_edit_lock%":"1699343123:4","%_edit_last%":"4","%_yoast_wpseo_primary_category%":"51","%_thumbnail_id%":"15798","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Paris, France","%_wpgmp_location_city%":"Paris","%_wpgmp_location_state%":"\u00cele-de-France","%_wpgmp_location_country%":"France","%_wpgmp_metabox_latitude%":"48.856614","%_wpgmp_metabox_longitude%":"2.3522219","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%twitter_share%":{"hashtags":["data #datascience"],"text":"WAN-IFRA's Data Science Expert Group intending to arm practitioners with insights, feedback, and tools to grow audiences, deepen user engagement, and optimise reader revenues."},"%twitter_card%":"Why WAN-IFRA launched the Data Science Expert Group for news ?, WAN-IFRA launched the Data Science Expert Group intending to arm practitioners with insights, feedback, and tools to grow audiences, deepen user engagement, and optimise reader revenues.","%_yoast_wpseo_metadesc%":"WAN-IFRA launched the Data Science Expert Group intending to arm practitioners with insights, feedback, and tools to grow audiences, deepen user engagement, and optimise reader revenues.","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"3","taxonomy=category":"Data Exploration, Media labs","taxonomy=post_tag":"data, data science"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15796,"infowindow_disable":false},{"source":"post","title":"Interview &#8211; Ouest M\u00e9dialab: Focus on local innovation key to staying \u201crooted in reality\u201d","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Interview &#8211; Ouest M\u00e9dialab: Focus on local innovation key to staying \u201crooted in reality\u201d\" width=\"300\" height=\"155\" src=\"https://media-innovation.news/wp-content/uploads/2023/07/OuestMediaLab-300x155.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Interview &#8211; Ouest M\u00e9dialab: Focus on local innovation key to staying \u201crooted in reality\u201d</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The collaborative media lab based in Nantes, France, works closely with local publishers and innovative players in their region. Direct contact with local players helps the lab stay focused on the real issues that companies in their network deal with.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/interview-ouest-medialab-focus-on-local-innovation-key-to-staying-rooted-in-reality/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The collaborative media lab based in Nantes, France, works closely with local publishers and innovative players in their region. Direct contact with local players helps the lab stay focused on the real issues that companies in their network deal with.","address":"28 Bd Benoni Goullin, 44200 Nantes, France","location":{"lat":"47.2017818","city":"Nantes","state":"Pays de la Loire","country":"France","lng":"-1.5532004","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/interview-ouest-medialab-focus-on-local-innovation-key-to-staying-rooted-in-reality/","zoom":2,"extra_fields":{"post_excerpt":"The collaborative media lab based in Nantes, France, works closely with local publishers and innovative players in their region. Direct contact with local players helps the lab stay focused on the real issues that companies in their network deal with.","post_content":"[vc_row content_placement=\"middle\"][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1>Interview - Ouest M\u00e9dialab: Focus on local innovation key to staying \u201crooted in reality\u201d</h1>\r\n<h4></h4>\r\n<h4></h4>\r\n<h3><em>The collaborative media lab based in Nantes, France, works closely with local publishers and innovative players in their region. Direct contact with local players helps the lab stay focused on the real issues that companies in their network deal with.</em></h3>\r\n&nbsp;\r\n\r\nIn 2018, we <a href=\"https://media-innovation.news/media-lab/ouest-medialab-a-cluster-and-independent-media-lab-that-supports-the-regional-digital-transition/\">spoke to Julien Kostr\u00e8che</a> who heads the <a href=\"https://www.ouestmedialab.fr/\">Ouest M\u00e9dialab</a> in Nantes, France. We caught-up with him this summer to ask him how things have moved forward since our last conversation<em>.</em>\r\n<h4><strong>WAN-IFRA: Julien, it\u2019s good to speak to you again. How have things evolved since 2018?</strong></h4>\r\n<strong>Kostr\u00e8che:</strong> Thanks! Between 2012 and 2018, Ouest M\u00e9dialab had as its scope of action the West of France (Brittany and Pays de la Loire) and brought together regional media, communication organisations and content creators in general on the issues of digital change.\r\n\r\nSince 2019, we have had a national scope and we focus our actions on the development, innovation and transitions of local media, no matter where they are located.\r\n\r\nWe pivoted for two main reasons:\r\n<ul>\r\n \t<li>To stay relevant in what we have to offer to local media who do not have the same means or problems as national ones.</li>\r\n \t<li>To find a balanced business model: the local authority \u201cR\u00e9gion Pays de Loire\u201d, which had supported us during the early years, was dwindling its financial support and it was difficult to find private partners if you only operate at a regional scale.</li>\r\n</ul>\r\n&nbsp;\r\n<h4><strong>Are you where you expected?</strong></h4>\r\nYes and no.\r\n\r\nNo, because when we launched Ouest M\u00e9dialab in 2012, we thought that our lab would directly initiate or even carry out collaborative R&amp;D projects among its members. But the media have not necessarily needed to set up collective projects or preferred going solo, and they needed to experiment or follow training in the shorter term.\r\n\r\nYes, because we have developed a qualitative monitoring of the media sector, we are established and recognised for our training course and workshops in digital journalism and we succeeded in developing sharing and mutual aid between local media, universities and some agencies or startups namely during the <a href=\"https://www.festival-infolocale.fr/\">Festival de l\u2019info locale</a> and our hackathons.\r\n\r\n&nbsp;\r\n<h4><strong>How collaborative are you with other media labs?</strong></h4>\r\nWe mainly exchange with a few francophone media labs or media startups/accelerators. I am thinking in particular of OFF7 (Sipa Ouest-France group), La compagnie Rotative (Centre-France group), the medialab of France T\u00e9l\u00e9visions or even IMI in Switzerland.\r\n\r\n&nbsp;\r\n<h4><strong>What do you see for the future of the lab and others in general?</strong></h4>\r\nI think we need to conduct more studies/surveys, to better understand the relationship between citizens and local news or identify any further good practices to innovate (whether at the editorial or business level). We also need to pay more attention to the new local actors and content creators (bloggers, Youtubers, streamers, Instagrammers, Tiktokers, influencers, etc.) and their relationship to the audience.\r\n\r\n&nbsp;\r\n<h4><strong>How do you measure your success?</strong></h4>\r\nWith the number of people who register to our newsletters (2,500), number of participants at the Festival de l\u2019info locale every year (400) or following our training and workshops (1,500 to 2,000 per year). And beyond the volume of people, by the satisfaction rate of people who participate in our actions.\r\n\r\n&nbsp;\r\n<h4><strong>And how about your staff turnover? Did you gain more employees?</strong></h4>\r\nWe are still 4 employees within our non-profit organisation (two full-time and two part-time), and I hope to be able to create a new job position next year.\r\n\r\n&nbsp;\r\n<h4><strong>How do you finance the projects?</strong></h4>\r\nIt depends on the projects. Our hackathons are for example funded by the membership of the media and schools, and some subsidies from the city of Nantes. For the festival, part of the income comes from the ticketing, the other part from sponsors like the Google News Initiative, Qiota or Riccobono Imprimeurs. And for training, there are specific funds within companies. Globally, our self-financing reached 85% with contributions and services and subsidies 15% of our annual budget.\r\n\r\n&nbsp;\r\n<h4><strong>What do you wish you had done differently?</strong></h4>\r\nThere are always things to improve, but overall, we have been able to maintain a good dynamic, by always testing/launching new actions. I have no regrets about the projects we have developed, except perhaps with NMcube, our media incubator that we set up in partnership with Audencia, the University of Nantes and another cluster. We coached 15 entrepreneurs of the media sector for a year and our programme helped them to get out of isolation, to grow or pivot. But we were unable to find private partners in the regions to sustain the system and avoid depending only on the public authorities\u2019 subsidies.\r\n\r\n&nbsp;\r\n<h4><strong>Do you stay in touch with the projects that have gone through your labs? If so, what is your relationship with them?</strong></h4>\r\nRelations are good. Some become members, others become occasional users of the lab, by participating in our workshops, hackathons or events. The link is rarely broken.\r\n\r\n&nbsp;\r\n<h4><strong>Has your process or approach to innovation changed?</strong></h4>\r\nNot really. We always rely on methods inspired by design thinking and user-centric methods. More frequent use is made of design fiction, in particular by working with the agency Design Friction, which is a member. And necessarily, with the new national scope of the lab and the Covid period, we have digitized several events or workshops, and have frequent online conferences, using tools like Miro or Jamboard.\r\n\r\n&nbsp;\r\n<h4><strong>What outside pressures do you face, if any?</strong></h4>\r\nA number of actors are in crisis or difficulty in the media sector. It\u2019s always been the case since we started but the recent rise in the cost of raw materials, paper in particular, aggravates the situation. On the side of the public authorities, there is often a tendency to decrease subsidies, or to only support projects at launch, and not the operation of the lab. Fortunately, Nantes M\u00e9tropole has supported us from the beginning and they were always there when we needed them.\r\n\r\n&nbsp;\r\n<h4><strong>Are there new partners?</strong></h4>\r\nYes. With the Festival de l\u2019info locale in particular, we have developed around 30 new partnerships. Our main private partner today is the Google News Initiative.\r\n\r\n&nbsp;\r\n<h4><strong>What has been the impact of Covid on the lab (have you downsized / how are events handled / the amount of work done face to face)?</strong></h4>\r\nIn think like many similar initiatives, partial unemployment at the start then progressive digitization of our services.\r\n\r\n&nbsp;\r\n<h4><strong>Biggest hits? Biggest failures? What did you learn from these?</strong></h4>\r\nSuccess: the Festival de l\u2019info locale, which has established itself in less than 5 years as a B2B event of reference for the sector.\r\n\r\nFailure: I don't want to appear lacking in modesty, but I don't see any big failures. Sometimes we have not been able to sustain some of our initiatives, like our media incubator. Other times, we terminated a project too soon. For example, in 2016, we launched a training course on virtual reality and 360-degree video which never started. Despite the interest about the subject, we were probably too far ahead of the maturity of this technology and the real opportunities for media professionals. But as a lab, our role is also to be a little out of phase and it's normal to crash from time to time. After all, it would be nice to have the luxury of crashing a little more often ;-)\r\n\r\n&nbsp;\r\n<h4><strong>Why do you think innovation in a city-based cluster is the way to go?</strong></h4>\r\nI don't know if this is the only way to go, but I'm certain that this allows us to be rooted in reality. We have direct contact with the local media and innovative players in our territory, and this continues to feed our thinking and plans, keeping a real anchor and awareness of the realities of the media sector.\r\n\r\n&nbsp;\r\n\r\nby Erin Wilson, Stephen Fozard and John Mills[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"Interview &#8211; Ouest M\u00e9dialab: Focus on local innovation key to staying \u201crooted in reality\u201d","post_link":"https://media-innovation.news/media-lab/interview-ouest-medialab-focus-on-local-innovation-key-to-staying-rooted-in-reality/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Interview &#8211; Ouest M\u00e9dialab: Focus on local innovation key to staying \u201crooted in reality\u201d\" width=\"300\" height=\"155\" src=\"https://media-innovation.news/wp-content/uploads/2023/07/OuestMediaLab-300x155.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"France, Media labs, Nantes","%_edit_lock%":"1699343018:4","%_edit_last%":"4","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"28 Bd Benoni Goullin, 44200 Nantes, France","%_wpgmp_location_city%":"Nantes","%_wpgmp_location_state%":"Pays de la Loire","%_wpgmp_location_country%":"France","%_wpgmp_metabox_latitude%":"47.2017818","%_wpgmp_metabox_longitude%":"-1.5532004","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_thumbnail_id%":"15777","%_wpcf_belongs_page_id%":"98","%_yoast_wpseo_primary_category%":"142","%_yoast_wpseo_metadesc%":"Ouest Medialab works with local publishers and innovators in their region to stay focused on the real issues that companies deal with.","taxonomy=category":"Media labs","taxonomy=post_tag":"France, Media labs, Nantes"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15772,"infowindow_disable":false},{"source":"post","title":"26-27 JANUARY 2023 \u2013 MEDIA LAB DAYS #6 Hamburg","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"26-27 JANUARY 2023 \u2013 MEDIA LAB DAYS #6 Hamburg\" width=\"300\" height=\"139\" src=\"https://media-innovation.news/wp-content/uploads/2023/03/MLD6-all-Screen-e1679934922366-300x139.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">26-27 JANUARY 2023 \u2013 MEDIA LAB DAYS #6 Hamburg</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The sixth WAN-IFRA Media Labs Days in Hamburg brought together media labs, academics and start-ups to talk innovation processes, Web3 and AI.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/media-lab-days-hamburg/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The sixth WAN-IFRA Media Labs Days in Hamburg brought together media labs, academics and start-ups to talk innovation processes, Web3 and AI.","address":"Hamburg, Germany","location":{"lat":"53.5488282","city":"Hamburg","state":"Hamburg","country":"Germany","lng":"9.987170299999999","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/media-lab-days-hamburg/","zoom":2,"extra_fields":{"post_excerpt":"The sixth WAN-IFRA Media Labs Days in Hamburg brought together media labs, academics and start-ups to talk innovation processes, Web3 and AI.","post_content":"[vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1><strong>Media Lab Days #6 heads to Hamburg\u00a0</strong></h1>\r\n<h4>The sixth edition of WAN-IFRA\u2019s Media Labs Days, this year held in Hamburg on January 26<sup>th</sup> and 27<sup>th</sup>, brought together media labs, academics and start-ups, focusing on themes like innovation processes, Web3 or AI, including the current opportunities and barriers facing the industry.</h4>\r\nDay one opened with a focus on Hamburg: the city of content and tech. Hamburg has a reputation for its creativity when it comes to media and technology and as a result this area has become a popular professional aspiration for many young people.\r\n\r\nParticipants heard from panellists how Hamburg is a burgeoning media hub and the progression of German-based media start-ups. Speakers included Paula Lauterbach, Communications Manager at <a href=\"https://www.nextmedia-hamburg.de\">nextMedia Hamburg</a>, manager partner Christoph H\u00fcning of <a href=\"https://nma.vc\">NMA Venture Capital</a>, Berndt R\u00f6ttger, Deputy Chief Editor <a href=\"https://www.abendblatt.de\">Hamburger Abendblatt</a> and Sophia Boysen, Product and Project Manager at software start-up <a href=\"https://bottalk.io\">BotTalk</a>.\r\n\r\n<img class=\"wp-image-15761 size-medium aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2023/03/MLD6-sign-screen-226x300.png\" alt=\"\" width=\"226\" height=\"300\" />Speakers discussed how start-ups are the essential catalyst for media innovation and how their companies invest and capitalise on supporting early start-ups, many through media incubators which act to support these growing companies. The work of start-ups is slowly starting to expand to include other sectors and foster collaboration, particularly with NMA Venture Capital, their work seeks to connect start-ups and corporates to foster collaboration and innovation.\r\n\r\nStart-up BotTalk was featured as an innovation case study. BotTalk is an audio content management system that provides excellent quality text-to-speech automation. The software was borne out of the rise of the pandemic which equated to the rise of the podcast and aims to work on making text-to-speech to be as human as possible. They currently have 10,000 linguistic rules, and more than 20,000 words in their dictionary, aiming to bring podcasts and text-to-speech together.\r\n\r\nAfternoon discussions also covered how media labs and accelerators are now recruiting young professionals and students to inspire out-of-the-box thinking and contribute to media innovation through collaborations with local Universities. Kim Svendsen, Chief Marketing Officer at <a href=\"https://www.stibodx.com\">Stibo DX</a> \u2013 our hosts for the two-day event - discussed how the company contributes to such media innovation. Stibo Systems owns and runs its own media lab, the <a href=\"https://www.stiboaccelerator.com\">Stibo Accelerator</a> in Aarhus, Denmark.\u00a0 The accelerator was established in 2014 and is currently running its 18th season to help the next generation of students aspiring to work in media innovation.\r\n<p style=\"text-align: center;\"><img class=\"aligncenter wp-image-15758 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2023/03/MLD6-Kim-scaled.jpg\" alt=\"\" width=\"2560\" height=\"1440\" /></p>\r\n<p style=\"text-align: left;\">The introduction on start-ups was supplemented by case studies on new labs from the WAN-IFRA community. The first example came from Helge O. Svela, CEO of <a href=\"https://mediacitybergen.no\">Media City Bergen</a> in Norway. Their work revolves around two main pillars:</p>\r\n\r\n<ul>\r\n \t<li><strong>A sustainable democracy:</strong> A fundamental force to empower important stories, ensure an informed population, and strengthen democracy. A well-working ecosystem to fuel editorial innovation, promote media diversity and fight filter bubbles and false information.</li>\r\n \t<li><strong>A world-leading technology hub:</strong> Media City Bergen is a leading, international hub for media and technology innovation.</li>\r\n</ul>\r\nThe second case study came from Joerg Pfeiffer, Product Manager at <a href=\"https://www.br.de/extra/ai-automation-lab/index.html\">BR AI + Automation Lab at Bayerrische Rundfunk</a>. His presentation discussed user-centric journalism with algorithms. Journalists can use algorithms in the newsroom to:\r\n<ul>\r\n \t<li>Support editors in their work processes</li>\r\n \t<li>Personalise services for users</li>\r\n \t<li>Open up large amounts of data</li>\r\n \t<li>Support research</li>\r\n</ul>\r\nThe use of algorithms can contribute more to the consumption of personalised content, reaching a fragmented audience as a public service broadcaster and providing consumers with hyper-regional news offering more relevant to their local area.\r\n\r\nThe final speaker in this session was Alexandra Folwarski, Team Lead at the <a href=\"https://www.inno-lab.at\">Media Innovation Lab</a> at Wiener Zeitung. Their media lab is formed of approximately eight media start-ups which are supported for nine months. The lab works as an incubator and accelerator, providing workshops and individual coaching in terms of support. This is provided by its Alumni programme which offers workshop sessions and more networking opportunities.\r\n\r\nThe day ended with a FOCUS session: Web3 for News Media: definitions, opportunities, state of play?\r\n\r\nHans Brorsen, European Blockchain Center at the IT University of Copenhagen, introduced Web3 - a new iteration of the World Wide Web which incorporates concepts such as decentralization, blockchain technologies, and token-based economics. The core ideas of web3 are:\r\n<ul>\r\n \t<li>Web3 is decentralised and censor proof</li>\r\n \t<li>Web3 is open and transparent</li>\r\n \t<li>Web3 is user-centric and enables digital ownership of assets and identities.</li>\r\n</ul>\r\nThe rest of the talk discussed the elements of Web3 including an overview of services surrounding blockchain technology, and a look at possible uses including crypto-wallets, NFTs (non-fungible tokens), DAOs (decentralised autonomous organisation) and decentralised storage.\r\n\r\nRa\u00fal Jaramillo, Project Manager at <a href=\"https://www.cogencylab.com\">Cogency</a>, an international coalition of content makers, designers and builders supported by WAN-IFRA developed further these conversations. Cogency runs projects that aim to have a meaningful impact and bring clarity and logic to help solve complex problems. He presented the concept of creating a decentralised digital identity which then sparked a debate about the opportunities of Web3 technologies for news media in the future.\r\n\r\n<img class=\"aligncenter wp-image-15759 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2023/03/MLD6-Violaine-scaled.jpg\" alt=\"\" width=\"2560\" height=\"1440\" />\r\n\r\nTo begin day two, discussions focused on how to create innovation, and where the place is for innovation in a media organisation?\r\n\r\nLina Timm, CEO of Medien.Bayern; Joachim Dreykluft, Member of the board of management for NOZ Digital, and Hendrik Lehmann, Head of the Tagesspiegel Innovation Lab formed a panel to focus in on this key question, covering successful and not-so-successful examples.\r\n\r\nMedien Bayern supports numerous start-ups and tried a membership connection and entrepreneurship programme which was unsuccessful. In the future, Lina Timm said they want to focus on how to cater for consumers better when it comes to media/news/innovation.\r\n\r\nNOZ Digital wanted to create a YouTube channel and incorporate this into a successful business model, but it failed due to a lack of interest from within. Joachim also talked about the failure of labs because of innovation - some people are ideas people and not product developers/businesspeople.\r\n\r\nFinally, Hendrik Lehmann talked about wanting to get into podcasts which would have required minimal costs, but the plan did not move forward at the time.\r\n\r\nAfter this panel, the conference continued with another FOCUS session on the latest in fact-checking, led by Nathalie Gallet, Journalist, M\u00e9diaLab de l\u2019information, France TV. Their fact-checking teams help journalists as well as the public to inform with reliable content and the public to share authentic information. One of their next projects is to partner with Norwegian factchecking initiative to create a search engine for fact-checked images/videos. In another related project, <a href=\"https://www.veraai.eu/home\">Vera.ai</a>, Denis Teyssou, Head of MediaLab AFP is focusing on disinformation analysis and AI-supported verification tools and services. Vera.ai is an EU funded project with the involvement of 8 research partners, 2 commercial organisations with relevant products and 2 global news and fact-checking providers.\r\n\r\nMoving to start-ups, Andy Taylor, CEO and Founder of <a href=\"https://www.bwlb.co.uk/\">Accordion</a>, introduced how his product allows users to automatically shorted play times for podcasts and video media. Taylor pitched that the technology allows listeners to adjust the length of their desired content without compromising on structure, tone or listenability. Christopher Brennan, Chief Product Officer at <a href=\"http://overtone.ai/\">Overtone.ai</a>, explained that his product aims to highlight \u2018quality\u2019 journalism. Using AI algorithms and natural language processing it focusses on the qualities of the text itself, rather than tertiary metrics such as clicks and shares. It highlights original reporting, good sourcing and the effectiveness of how ideas are explored and expressed. Overtone.ai wants content to be assessed on its actual quality rather than click-based metrics.\r\n\r\nThe end of the second and final day was marked with the closing discussion on large language models, including ChatGPT and its siblings. Language models like ChatGPT are particularly topical at the moment given their popularity for producing accurate content. The idea behind this kind of software is to build a structure similar to the human brain which can generate text on any topic. The software incorporates information from sources like websites, social media and scientific publications. The potential of ChatGPT in our industries could be to:\r\n<ul>\r\n \t<li>Improve efficiency in content creation</li>\r\n \t<li>Focus journalistic attention on Investigation</li>\r\n \t<li>Reduce costs for engaging viewers/readers</li>\r\n</ul>\r\nChatGPT is already proving effective in the field of media when it comes to writing and creating copy and content. ChatGPT is an extrapolation of a class of machine learning Natural Language Processing models known as Large Language Model (LLMs). LLMs digest huge quantities of text data and infer relationships between words within the text.\r\n\r\nThe final thought of the conference came from Rolf Dyrnes Svendsen, chair of the GAMI board, who highlighted how important these conversations are for the industry and how important it is to exchange and network with our peers and like-minded people.\r\n\r\n<span style=\"text-decoration: underline;\"><strong>Media Labs Day #7 will take place in Bergen in the autumn \u2013 join our Global Alliance for Media Innovation to be there too\u2026</strong></span>\r\n\r\n&nbsp;\r\n\r\nWritten by Erin Wilson.[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"26-27 JANUARY 2023 \u2013 MEDIA LAB DAYS #6 Hamburg","post_link":"https://media-innovation.news/media-lab/media-lab-days-hamburg/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"26-27 JANUARY 2023 \u2013 MEDIA LAB DAYS #6 Hamburg\" width=\"300\" height=\"139\" src=\"https://media-innovation.news/wp-content/uploads/2023/03/MLD6-all-Screen-e1679934922366-300x139.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"Hamburg, Media labs","%_edit_lock%":"1689853855:4","%_edit_last%":"4","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"15760","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Hamburg, Germany","%_wpgmp_location_city%":"Hamburg","%_wpgmp_location_state%":"Hamburg","%_wpgmp_location_country%":"Germany","%_wpgmp_metabox_latitude%":"53.5488282","%_wpgmp_metabox_longitude%":"9.987170299999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_wp_old_date%":"2023-03-27","%_yoast_wpseo_focuskw%":"Media Lab","%_yoast_wpseo_title%":"MEDIA LAB DAYS #6 Hamburg on innovation, Web3 and AI","%_yoast_wpseo_metadesc%":"The sixth WAN-IFRA Media Lab Days in Hamburg brought together media labs, academics and start-ups to talk innovation processes, Web3 and AI.","%_yoast_wpseo_linkdex%":"67","%_wp_old_slug%":"26-27-january-2023-media-lab-days-6-hamburg","taxonomy=category":"Media labs","taxonomy=post_tag":"Hamburg, Media labs"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15757,"infowindow_disable":false},{"source":"post","title":"Inholland&#8217;s Sustainable Media Lab: imagining socially, environmentally and technically sustainable infrastructure","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"A photograph of Holland with graphics of &#039;network connections&#039; linking different areas\" width=\"300\" height=\"154\" src=\"https://media-innovation.news/wp-content/uploads/2022/08/Sustainable-Media-Lab-300x154.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Green media, Innovation Case</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Inholland&#8217;s Sustainable Media Lab: imagining socially, environmentally and technically sustainable infrastructure</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Inholland's Sustainable Media Lab is leading the way on imagining socially, environmentally and technically sustainable infrastructure.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/sustainable-media-lab/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Inholland's Sustainable Media Lab is leading the way on imagining socially, environmentally and technically sustainable infrastructure.","address":"Prinsegracht 27, 2512 EW Den Haag, Netherlands","location":{"lat":"52.0749586","city":"Den Haag","state":"Zuid-Holland","country":"Netherlands","lng":"4.306508300000001","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/sustainable-media-lab/","zoom":2,"extra_fields":{"post_excerpt":"Inholland's Sustainable Media Lab is leading the way on imagining socially, environmentally and technically sustainable infrastructure.","post_content":"[vc_row][vc_column width=\"1/4\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1>Inholland's Sustainable Media Lab: imagining socially, environmentally and technically sustainable infrastructure</h1>\r\nThe <a href=\"https://www.sustainablemedialab.eu/\">Sustainable Media Lab</a> at the <a href=\"https://www.inholland.nl/inhollandcom/\">Inholland University of Applied Sciences</a> in the Hague was founded in 2021, and is led by social scientist and Professor of Media, Technology and Society Ben Wagner.\r\n\r\nHe has worked on human-rights technology for more than a decade, including serving as founding Director of the Center for Internet and Human Rights at European University Viadrina and as Director of the Sustainable Computing Lab at Vienna University of Economics.\r\n\r\n\"I actually see sustainability as a way of mainstreaming ideas around human rights,\" Wagner explains. \"Because lots of people get challenged or feel anxiety when they're dealing with things related to human rights, it's a shame, but it's a reality. So finding some context that allow us to communicate things that matter, but are not so directly confrontational, means they can be better integrated in people's everyday lives.\"\r\n\r\nInholland has expertise in media research, but the university was keen to build sustainability into its work here, and through the 'living lab' idea they hoped to to engage people on these issues in different ways.\r\n\r\n\u201cI previously worked in a sustainable computing lab, which is all about sustainable technology, so there was an interesting overlap to explore,\" he says. \"And we\u2019re now starting to create a body of literature in this area, so we have concepts that we can talk about.\u201d\r\n\r\nThe lab is\u00a0currently working with the Municipality of The Hague, <a href=\"https://hivos.org/\">Hivos</a>, an international-development NGO and <a href=\"https://greenhost.net/\">Greenhost</a>, which is a Dutch company that provides ethical web-hosting.\r\n\r\n\"These projects are all about building more sustainable technological infrastructures, supporting creative businesses and artists to be able to access them, and then communicating to the public why it's better to use them.\r\n\r\n\"By sustainable infrastructure, we mean societally, environmentally and technically. All three parts of that stack. So not being patched every five minutes and constantly falling apart. Not having negative societal impacts by being large multinational conglomerates, which are so monopolistic that you can't trust them to use your data. And also having a reasonable environmental footprint.\"\r\n\r\nIn February this year, <a href=\"https://www.sustainablemedialab.eu/2022/04/20/what-would-sustainable-media-feel-like/\">the lab heard from Kay Meseberg, from ARTE</a>, the European public-service channel, an event that highlighted to Wagner that \"there\u2019s a conversation that needs to be had about behaviour change\".\r\n\r\n\"They were basically saying that the old Hertzian model for television is much more sustainable than the streaming world, because streaming requires all these data centers and all of these other things. We actually had all of these really efficient technologies that we stopped using, but of course, now they're not very compatible with streaming behaviour of users today.\r\n\r\n\"And we're actually very good at developing technologies that reduce energy consumption, but then we start using more of them. Like having more efficient engines and then driving big SUVs. If we just had the same sized cars we did 50 years ago and the engines we have now, we'd be much more efficient.\r\n\r\n\u201cI think part of the problem with media technologies today is that the stack is set up in such a way that each additional viewer has a significant additional cost, it\u2019s energy intensive. I don't think that it has to be that way. The infrastructures that we've built have led to a set of choices that de facto make it that way.\r\n\r\n\u201cSo we have to acknowledge that and say \u2018that's a problem because you're creating these trade-offs, between things like economic and environmental issues, but the trade-offs are not technically necessary\u2019. It's more that they've become necessary by virtue of a path dependency.\u201d\r\n<h3>Challenging consumer and corporate behaviour</h3>\r\nWagner suggests our current, unsustainable path is based on misunderstandings, both at a corporate, and a consumer, level.\r\n\r\n\"The idea that you would have to use always the highest, best, most-advanced, fancy setting to sell the product is just very ingrained in the providers. A lot of the time, it's about setting defaults for people so that they have the choice, but making the choice, by default, more reasonable.\r\n\r\n\u201cI find it absurd when I open any streaming app on my phone, and I\u2019ve done this on the phones of colleagues as well, and the default choice is streaming HD with maximum bandwidth. I have normal eyesight, and I can't tell the difference on my phone between maximum HD and standard definition, because the screen is tiny. And, when you're looking at video streaming, changing this would reduce the data involved by a factor of 10.\r\n\r\n\"Similarly, a lot of cars have an \u2018eco\u2019 setting, but it's not selected by default, so nobody bothers to use it. If have to change into \u2018sports\u2019 mode, most people would probably just not change it. So it's about setting things up so it's easy to do the right thing.\r\n\r\n\u201cCompanies are building their business models based on assumptions that I think are false about consumer behaviour. They assume that if you annoy or frustrate your customers too much, then they're not going to be willing to use the product. I think actually a lot of the research suggests that consumers are perfectly willing to do things like this. They just expect some kind of transparent justification on the way and then they're happy to be part of it.\"\r\n\r\nAnd he says these assumptions creep into media companies, too. \"Many media companies believe you\u2019re there to make the consumer happy or to entertain them, to make their lives easier. That's how we design our products. That's how we engineer our systems. That's how we think about the world.\r\n\r\n\u201cBut if we think about the world like that, we'll never be able to change our carbon footprints. So it becomes a very real question of \u2018how do you take the user with you on a journey, so that they're willing to make these behavioural changes, after they've already bought your devices, after they've already become fans of your programme?\u2019.\r\n\r\n\u201cYou don't want to completely frustrate them. You don't want to not have a market anymore. But you also have a responsibility to find ways to make that behaviour adapt.\u201d\r\n\r\nHe points out this challenge may be easier to tackle depending on your audience. \u201cI'd be really interested in how Fox News is going to deal with its carbon footprint,\u201d he suggests. \u201cI'm not saying I have an answer to it, but it's just that, if you go down that path, that inevitably means that you need to engage with a different idea of your consumers.\r\n\r\n\"It's all a question about the behaviours we've created and whether it's possible, with these new behaviours, to adapt the technologies to be more sustainable, or whether we\u2019ll then just create new more ecologically costly business models to adapt again. There's definitely a cycle going on there.\u201d\r\n\r\nWagner also points to an issue with \u201clag time\u201d in terms of product development. \u201cThe stuff that we're using right now is basically based on things that were imagined 10 years ago. And 10 years ago, in the economic circles that were building these products, sustainability just wasn't that much of a thing. And if it was, it was very much about nudging people to do the right thing, rather than building infrastructure that enables people to do the right thing by default.\u201d\r\n<h3>Niche companies nudging the market to do better</h3>\r\nThe Sustainable Media Lab has an upcoming project with radical Dutch smartphone manufacturer <a href=\"https://www.fairphone.com/en/\">Fairphone</a> \u2013 that says it's working 'for people and planet'.\r\n\r\n\"They're one of the companies we use as a great example for the way they\u2019re doing this,\" Wagner explains. \"I don't think it's about them outrunning the Apples of this world. When you really get down to it, they're pretty clear that their product doesn't have to be the dominant product to be successful.\r\n\r\n\"What they've done is created a niche product, which is very successful, but they've also pushed everybody else in the industry to look long and hard at themselves to see if they can do better. A lot of the sourcing of minerals for iPhones and in other products has gotten much, much better because of the standards Fairphone has set, they've shown that it's possible.\u201d\r\n\r\nAsked about whether there's a real answer to the issues of human-rights abuses in the electronics supply chain, he adds \"I don't think that there's any easy, binary answer to any of these questions\".\r\n\r\n\"Will there always be conflicts about this? Definitely. Does this mean that it's worthless to strive for improving the situation? No, I think it still makes a lot of sense. And that's why I think what Fairphone is doing is really valuable, because it shows that much more is possible. And what Fairphone has done is materially improved the lives of tens of thousands of people.\u00a0 There's no question about it. And not just in their own supply chain, but in supply chains across the world.\"\r\n\r\nBut, he says, looking at supply chains alone is insufficient \u2013 \"you need to see the phone in its whole ecosystem content \u2013 the content that's on the phone, the technology in the phone, how the phone is used\".\r\n\r\n\u201cThat's what we call these \u2018social-technical\u2019 systems,\" he explains. \"You can't just see the technology. It's about the people and how they use it. And that interaction creates the interesting phenomena that I think is worth looking at.\r\n\r\n\u201cIf you're if you're looking at your carbon footprint as a television station, the vast majority of your carbon footprint is people watching your product. It's not the production cost itself, so that\u2019s all of your viewers buying televisions and turning them on and watching your television shows.\r\n\r\n\u201cSo if you want to change or improve your carbon footprint \u2013 you inevitably have to work on influencing your viewer behaviour. And the same goes for the phone manufacturers and everybody else \u2013 to start influencing not just the technology and the technological solutions \u2013 but also human behaviour. Otherwise, there's no way to get any meaningful effect on carbon footprints.\u201d\r\n<h3>A sustainable future?</h3>\r\nLooking to the future of the lab, Wagner explains that he thinks the next 10 years is going to bring many more Fairphone-like ventures.\r\n\r\n\u201cI would assume there'll be dozens of these companies, they'll all be super successful around these things that the big companies aren't able to cover. And that'll hopefully create ecosystems that are very different from what we have now. And then there'll be opportunities that are not based on relying on these large companies.\r\n\r\n\u201cFrom what I've seen, the larger the industry, the less they understand. So lots of the small ones see these things as a competitive advantage, and really are interested and excited in doing these things. The big ones just have too much to lose if they go down that path, because initially it challenges too much of their models of scale and the harmful ways they do their business.\r\n\r\n\u201cI wouldn't expect a lot of change among multinationals, but it\u2019s also on us, if we're going to allow them to be the only players in the game, right ? If they're the only people who make the decisions, then we have a problem regardless, not just about sustainability. So that needs to change.\r\n\r\n\u201cI believe that it's possible to strive towards this kind of sustainability \u2013 I don't yet know what it'll mean to get there.\u201d\r\n\r\n<span style=\"font-weight: 400;\">CONTACT</span>\r\n\r\n<span style=\"font-weight: 400;\">Ben Wagner, Professor of Media, Technology and Society at Inholland at Lab Director at the Sustainable Media Lab.</span>\r\n\r\n<span style=\"font-weight: 400;\">Twitter:</span> <a href=\"https://twitter.com/benwagne_r\"><span style=\"font-weight: 400;\">@BenWagne_r</span></a>[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"Inholland&#8217;s Sustainable Media Lab: imagining socially, environmentally and technically sustainable infrastructure","post_link":"https://media-innovation.news/media-lab/sustainable-media-lab/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"A photograph of Holland with graphics of &#039;network connections&#039; linking different areas\" width=\"300\" height=\"154\" src=\"https://media-innovation.news/wp-content/uploads/2022/08/Sustainable-Media-Lab-300x154.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Green media, Innovation Case","post_tags":"ARTE, Ben Wagner, Greenhost, Hivos, Inholland, Kay Meseberg, Sustainable infrastructure, Sustainable Media Lab, The Hague","%_edit_lock%":"1689853894:4","%_edit_last%":"933","%_oembed_82c5143ec317635c1f9cab3f8d91a067%":"{{unknown}}","%_yoast_wpseo_primary_category%":"69","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Prinsegracht 27, 2512 EW Den Haag, Netherlands","%_wpgmp_location_city%":"Den Haag","%_wpgmp_location_state%":"Zuid-Holland","%_wpgmp_location_country%":"Netherlands","%_wpgmp_metabox_latitude%":"52.0749586","%_wpgmp_metabox_longitude%":"4.306508300000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_focuskw%":"Sustainable media lab","%_yoast_wpseo_title%":"Sustainable Media Lab: social, environmental and technical sustainability","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"9","%_thumbnail_id%":"15739","%_yoast_wpseo_metadesc%":"Inholland's Sustainable Media Lab is leading the way on imagining socially, environmentally and technically sustainable infrastructure.","taxonomy=category":"Green media, Innovation Case","taxonomy=post_tag":"ARTE, Ben Wagner, Greenhost, Hivos, Inholland, Kay Meseberg, Sustainable infrastructure, Sustainable Media Lab, The Hague"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15735,"infowindow_disable":false},{"source":"post","title":"GAMI Briefing #4: Media Labs session (17.02.22)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"GAMI Briefing #4: Media Labs session (17.02.22)\" width=\"300\" height=\"110\" src=\"https://media-innovation.news/wp-content/uploads/2022/03/Capture-de\u0301cran-2022-03-14-a\u0300-11.31.16-300x110.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">GAMI Briefing #4: Media Labs session (17.02.22)</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/gami-briefing-4-media-labs-session-17-02-22/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","address":"Paris, France","location":{"lat":"48.856614","city":"Paris","state":"\u00cele-de-France","country":"France","lng":"2.3522219","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/gami-briefing-4-media-labs-session-17-02-22/","zoom":2,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>GAMI Briefing #4: Media Labs session (17.02.22)</h1>\r\n<h4></h4>\r\n<h4>Media labs, innovation networks, accelerators and start-ups from across Europe, the fourth edition of GAMI\u2019s regular online briefings covered a diverse range of innovations and ways to innovate.</h4>\r\n&nbsp;\r\n\r\nThese included new approaches to broadcast technology, AI-powered podcast experiences, open innovation networks that supported media and data-journalism powered by the internet of things.\r\n<ul>\r\n \t<li>Norway\u2019s NRKbeta demonstrated how it delivers technology innovation and market insights to the country\u2019s public broadcaster.</li>\r\n \t<li>Der Tagesspiegel\u2019s Innovation Lab described how it uses the power of audiences and interactive visualisation to conduct and convey data journalism.</li>\r\n \t<li>France\u2019s La Voix du Nord (LVDN)\u2019s incubator \u2013 La Fabriq \u2013 outlined some of the success products it had developed.</li>\r\n \t<li>The session also introduced the 1Kubabor open innovation network and its Syllabus media accelerator also linked to LVDN</li>\r\n \t<li>podcast start-up Bwlb showed its ACCORDION product, which allows users to change the duration of podcasts but without losing the essence and integrity of the content.</li>\r\n</ul>\r\n&nbsp;\r\n<h3><strong>NRKbeta: R&amp;D, Technology Journalism, Insights</strong></h3>\r\nAnders Hofseth, strategic advisor and journalist at NRKbeta lab within the Norwegian Broadcasting Corporation, kicked off the session by explaining NRKbeta\u2019s core activities. A team of seven conduct research and development around new tech, products and processes \u2013 creating new approaches to broadcast media. Hofseth discussed a range of initiatives that formed part of their R&amp;D work. These included audio sensitive cameras developed in house using Arduino board and Go-Pro cameras that are able to detect audio from specific speakers, and form there automated video always showing the speaker. Hofseth said this tech has been used on the main broadcast channel and across the web.\r\n\r\nThe second activity the lab runs is technology journalism; creating editorial material for public output. Hofseth described a project where the team purchased a big data set to understand how individuals\u2019 data could be used by third parties.\r\n\r\n&nbsp;\r\n\r\n<img class=\" wp-image-15712 aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2022/03/Anders-Hofseth-300x169.png\" alt=\"\" width=\"556\" height=\"313\" />\r\n\r\n&nbsp;\r\n<blockquote>\u201c<em>We found vulnerable targets like politicians with military people who could have been targeted and blackmailed, and we could find people like me and you'd see them go to work, go to hospital and see them meeting people.\u201d</em>\r\n\r\n&nbsp;</blockquote>\r\nWhen speaking to an individual who\u2019s data had been captured and analysed, Hofseth said \u201che was really surprised and quite freaked out when we found him and told him that we know exactly where you were two years ago.\u201d\r\n\r\nSpeaking broadly about these activities, Hofseth explained they are \u201creally about seeing where the technical possibilities are aligning with your goals and charting what things you can do with them to help you reach your goals better.\u201d\r\n\r\nThe lab also creates insights to benefit the broadcaster more strategically. Discussing the buzz around apps such as Clubhouse, Hofseth said the lab navigates fads \u2013 enabling their organisation to protect their resources and concentrate on future trends that can provide real benefit.\r\n<blockquote>&nbsp;\r\n\r\n<em>\u201c[Our] purpose is really helping NRK to carry that public service [role] into the 21st century because we need to understand things and do the right stuff and not do too much of the wrong stuff if we want to be around in 50 years.\u201d</em></blockquote>\r\n&nbsp;\r\n\r\nRead a full article about NRKbeta <a href=\"https://media-innovation.news/media-lab/public-service-media-innovation-21st-century/\">here</a>\r\n\r\n&nbsp;\r\n<h3><strong>Der Tagesspiegel Innovation Lab: new forms of storytelling; empowering journalism</strong></h3>\r\nA team of journalists, designers and coders, Der Tagesspiegel\u2019s Innovation lab is involved in a range of data journalism and tech development projects. At the heart of the lab is collaboration, both within their organisation and beyond it.\r\n\r\nHendrik Lehmann, head of the lab, explained that one of the key motivating factors for the lab was to create \u2018empowering journalism\u2019.\r\n\r\nThis includes equipping colleagues in Der Tagesspiegel with tools to create journalism in a data-driven age, empowering citizens in a complex digital ecosystem, involving users in research, collaborating with scientists and start-ups, translating global problems into local and personal stories and creating stories that connect with people emotionally and politically.\r\n\r\nLehmann provided a range of project examples to outline their work. Radmesser used the \u2018journalism of things\u2019 \u2013 a take on the internet of things, to explore safety for cyclists. The team created 100 sensors and distributed them among citizens for use on their bikes. The sensors could detect how close cars were to the bikes. The initial phase of the project recorded 16,000 events and found that 56% broke safe passing rules. The sensors were open sourced and are now used in other cities within Germany and beyond.\r\n\r\n&nbsp;\r\n\r\n<img class=\" wp-image-15713 aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2022/03/Hendrik-2-300x169.png\" alt=\"\" width=\"552\" height=\"311\" />\r\n<blockquote>&nbsp;\r\n\r\n<em>\u201cThe results were very unique and we produced this map of it - you could look for your address in and visualize areas in the city where it was especially dangerous. It changed a lot of the discourse in Germany. It led to a change in the law on the national level, not only that project, but the wider discussion around it.\u201d</em></blockquote>\r\n&nbsp;\r\n\r\n<strong>Spectrum of projects</strong>\r\n\r\nThe lab leader also talked about the breadth of project they\u2019ve been involved in. These range across Wem Geh\u014drt Berlin? an international investigation of property investment and ownership \u2013 starting in Berlin, and later expanding to multiple cities. Interactive tools that allow readers to understand environmental impact \u2013 such as a calculator that lets users to understand how eco-friendly (or not) their meals are.\r\n\r\n<strong>Covid</strong>\r\n\r\nThe team have been involved in Covid coverage at Der Tagesspiegel in a number of ways. One example Lehman provided was a Covid tracking map initially created at the beginning of the pandemic. Lehmann explained that it's been the most successful article Der Tagesspiegel has ever had.\r\n<blockquote><em>\u201cIt has a few dozen million views. Every day, it's among the top viewed articles, and the main function of this is that people are able to look for their area and see the results and look for certain countries and also see the results. Also, it has comparison features where we develop different kind of data visualisations and you can highly customize it. \u2026 We tracked [use] and it's about 10 clics per visit, so people use 10 different tools and 10 kind of inputs to visit, which normally would be unlikely. The engagement on this website is really high\u201d</em></blockquote>\r\n&nbsp;\r\n\r\nRead more about Der Tagesspiegel innovation lab <a href=\"https://media-innovation.news/media-lab/der-tagesspiegel-interdisciplinary-and-audience-engaged-innovation/\">here</a>\r\n\r\n&nbsp;\r\n<h3><strong>New incubator: new solutions at La Voix du Nord</strong></h3>\r\nNext up was Lucie Delorme, the head of the La Fabriq incubator at la Voix du Nord in Lille. La Voix du Nord is an 80-year-old newspaper and website, which reaches one million readers a day. Delorme described her and the organisation\u2019s innovation journey, which began six years ago with a design thinking process. This saw 20 employees taking one day a week for five weeks to create new products and services, and the creation of an incubator.\r\n\r\nDelorme explained the incubator is centred on a simple concept - \u201ceveryone in the company can have a very good idea. And it would be so great to push it and to help [it to be] developed.\u201d\u00a0 The incubator supports a range of activities \u201cIt's not only new products, new mediums, it's also new processes, new ways to save time or money. It's just the opportunity, the time and the money to achieve those ideas,\u201d she explained.\r\n\r\n&nbsp;\r\n\r\n<img class=\" wp-image-15714 aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2022/03/Lucie-Delorme-300x169.png\" alt=\"\" width=\"550\" height=\"310\" />\r\n\r\n&nbsp;\r\n\r\nA range of products have been developed through the incubator since it started.\r\n<ul>\r\n \t<li><strong>Vozer</strong>: an \u2018urban pure player\u2019 that creates content for millennials without any print product. Incubated for six months, the product now has 250,000 readers and has a viable business model, staffed with four team members.</li>\r\n \t<li><strong>Pigeon Master: </strong>North of France sees a large community of pigeon fanciers. This is an auction sales platform and media site. Content is created by journalists from across the news organisation</li>\r\n \t<li><strong>Ta Voix: </strong>aimed at teenaged readers and provides news content on Instagram and Snapchat and media education within schools \u2013 delivering information around fake news and how to source valid information within our digital ecosystem.</li>\r\n</ul>\r\n&nbsp;\r\n\r\nDelorme also talked about La Fabriq 2.0, which now has a team of eight taken from across the organisation, and supports new ideas and products and provides design thinking training.\r\n<blockquote>&nbsp;\r\n\r\n<em>\u201cWe managed to organize a very cool design thinking training. That was very good for us because you can be a very good journalist, you can be a very good web analyst, but you need training in design thinking if you want to work in an incubator. So this is what we did \u2026 all the eight good coaches are now well trained. This is the best way for us to help people incubate within La Fabriq.\u201d</em></blockquote>\r\n&nbsp;\r\n<h3><strong>National and international open innovation networks</strong></h3>\r\nSpeaking next was Paola Villalba, head of Acc\u00e9l\u00e9rateur Syllabus M\u00e9dia, 1Kubator La Voix du Nord. Villalba explained the link between her organisation and La Fabriq.\r\n\r\n1Kubator is an open innovation network, the first in France, and has a range of incubators across the country \u2013 including with la Voix Du Nord \u2013 and beyond. Working in countries such as China, Burkina Faso and Senegal.\r\n\r\n&nbsp;\r\n<blockquote><em>\u201cWe facilitate innovation at different levels from the person looking to explore enterprise shape through information where we finance and invest in startups and acceleration, and all the way to working with corporate groups and helping them tackle digital transformation. We want to make it possible for all of them to benefit from our network, have access to different resources and help startups become nationwide a lot faster.\u201d</em>\r\n\r\n&nbsp;</blockquote>\r\n<img class=\" wp-image-15715 aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2022/03/Paola-Villalba-300x167.png\" alt=\"\" width=\"528\" height=\"294\" />\r\n\r\n&nbsp;\r\n\r\nVillalba outlined the type of activity the network creates in order to build this innovation:\r\n<blockquote>&nbsp;\r\n\r\n<em>\u201cWe have innovation, challenges, entrepreneurship, extra partnership hackathons and different design. And yes, design thinking bootcamps for them. And the other one that we have is very specific, which is the open innovation accelerators. </em><em>[Our] ambition is to create an innovation network for media groups where what we do with one media and one startup may be replicated in other local newspapers. This works in France because these media groups are not in competition with each other.\u201d</em></blockquote>\r\n&nbsp;\r\n\r\nTalking about the Syllabus Media accelerator at La Voix du Nord, Villalba explained that this accelerator enables the publisher to connect with start-up to accelerate its digital transformation through identifying innovation solutions to the challenges they face.\r\n\r\nSyllabus media works in two ways. Identifying trends and opportunities externally or identifying internal needs within the publisher, and then working with start-ups to help connect them to a challenge. These start-ups can help shorten the time to market to help new solutions. The start-ups can also take advantage of training and development opportunities via the accelerator and network.\r\n\r\nThe programmes last between 6 and 12 months, and it has worked with a range of organisations spanning education, advertising and content creation. It tests products and business models quickly and effectively. There are three main areas that the network focusses on:\r\n<ul>\r\n \t<li><strong>Diversification</strong>: new business models, new products and solutions</li>\r\n \t<li><strong>New types of content:</strong> exploring new channels such as podcasts, virtual reality and augmented reality</li>\r\n \t<li><strong>New tools and solutions</strong>: internal systems that allow publishers to increase efficiency, understand audience data and/create better content</li>\r\n</ul>\r\n&nbsp;\r\n\r\nTwo successful examples are \u2018Rematch\u2019, which collects video highlights from amateur sports and amplifies these on social channels. Clubs upload directly to the app and journalists can use the content on special programming and outputs. \u2018Trusty\u2019 is a dynamic job board solution that is still being accelerated in conjunction with La Voix du Nord. It allows those hosting jobs pages to customise their websites and offer different services.\r\n\r\n&nbsp;\r\n<h3><strong>Bwlb: ACCORDION</strong></h3>\r\nFinally, Andy Taylor introduced his start-up Bwlb. Based in Wales, Bwlb\u2019s ACCORDION creates \u201csmart podcasts\u201d, which sees the audio adjusted to fit the time users have available. Taylor suggested that this increases the \u201camount of control and convenience that the listeners can have in the future\u201d. Using AI tech, Bwlb aims to provide shortened podcasts that still retain the core story. Essentially, superfluous elements are removed so the essence of the podcasts are retained. Users can define how much time they have, and the audio is edited to the right play time.\r\n\r\n&nbsp;\r\n<blockquote><em>Taylor explains: \u201cWe think that there needs to be a breakthrough in audio, specifically in podcasting, where listeners get a lot more control and convenience in the same way they have with visual media. So this is what accordion aims to do, it gives the listener a chance to adjust the duration of any podcast episode without losing structure, tone or listenability.\u201d</em></blockquote>\r\n&nbsp;\r\n\r\n<img class=\" wp-image-15716 aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2022/03/Bwlb-300x141.png\" alt=\"\" width=\"575\" height=\"270\" />\r\n\r\nBwlb is working on full automation and is interesting in working with small, medium or large organisations to take the product to the next level. The key element behind the product is the experience \u2013 creating a seamless audio experience even though it is condensed.\r\n\r\n\u201cIt'll still sound like the podcast you know and love,\u201d Taylor added.\r\n\r\n&nbsp;\r\n\r\n<em><span style=\"text-decoration: underline;\"><strong>The next GAMI Briefing will take place online before the summer and hopefully a new edition of the \u201cin-person\u201d Media Labs days will be taking place later in the year\u2026</strong></span></em>\r\n\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_column_text]\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>[/vc_column_text][/vc_column][/vc_row]","post_title":"GAMI Briefing #4: Media Labs session (17.02.22)","post_link":"https://media-innovation.news/media-lab/gami-briefing-4-media-labs-session-17-02-22/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"GAMI Briefing #4: Media Labs session (17.02.22)\" width=\"300\" height=\"110\" src=\"https://media-innovation.news/wp-content/uploads/2022/03/Capture-de\u0301cran-2022-03-14-a\u0300-11.31.16-300x110.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"","%_edit_lock%":"1679934877:4","%_edit_last%":"4","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"15717","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Paris, France","%_wpgmp_location_city%":"Paris","%_wpgmp_location_state%":"\u00cele-de-France","%_wpgmp_location_country%":"France","%_wpgmp_metabox_latitude%":"48.856614","%_wpgmp_metabox_longitude%":"2.3522219","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"11","taxonomy=category":"Media labs","taxonomy=post_tag":""},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15711,"infowindow_disable":false},{"source":"post","title":"FASTlab: Future Arts, Science and Technology Laboratory","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"FASTlab: Future Arts, Science and Technology Laboratory\" width=\"300\" height=\"224\" src=\"https://media-innovation.news/wp-content/uploads/2022/02/FastLab-Oz-300x224.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">FASTlab: Future Arts, Science and Technology Laboratory</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/fastlab-future-arts-science-and-technology-laboratory/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","address":"Newcastle NSW, Australia","location":{"lat":"-32.9282712","city":"Newcastle","state":"New South Wales","country":"Australia","lng":"151.7816802","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/fastlab-future-arts-science-and-technology-laboratory/","zoom":2,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]<em>Our latest media lab piece comes from Professor Paul Egglestone, Head of School of the Creative Industries in the College of Human and Social Futures at the University of Newcastle, Australia. Egglestone is a founding member of the Global Alliance for Media Innovation and formerly founder of the Media Innovation Studio at the University of Central Lancashire. Here, he describes FASTlab: a new hub for creative and transdisciplinary innovation and creation. Egglestone outlines its aims, work and future impact, and shares thoughts around how the news media could benefit from collaborative and community-based approaches to real world challenges they face, and create sustainable and thriving operations in the future...</em>\r\n\r\n&nbsp;\r\n<h1><strong>Imagining better:\u00a0 </strong><strong>Future Arts, Science and Technology laboratory </strong></h1>\r\nThe Future Arts, Science and Technology Laboratory - FASTlab - is home to great ideas inspired by bringing together the brightest people to figure out how to make things better. We know that imagination is the foundation of creativity and innovation. We celebrate the unique quality of our humanity through our creative ability to imagine things that don\u2019t exist yet and our capabilities to turn what we\u2019ve imagined into something real. Something better.\r\n\r\nWe are alive in a time when the world as we knew it, together with our faith in the future, is disappearing. New uncertainties for individuals, society and the planet are now hallmarks of the so-called Anthropocene - the \u2018New Normal\u2019. If we are to attain sustainable economic growth alongside balanced social and environmental development, we need to radically rethink how businesses, government and NGOs can create value through creativity and innovation. Creativity that is\u00a0rooted in sustainable social, economic, environmental, and cultural practices.\r\n<h2>Open to collaboration with media...</h2>\r\nThis is potentially furtive ground for news media organisations traditionally charged with holding those in power to account and providing us with the information needed to make informed decisions. It provides an opportunity for a journalism that recognises its own existential crises and cannot be separated from the need to create a sustainable society, ecologically, economically, and socially. It calls for a journalism that understands and accepts its \u2018social licence\u2019 \u2013 that implicit basic permission society gives to any corporate organisation to conduct its activities \u2013 will be increasingly threatened if it fails to adequately address the sustainability challenges facing humanity.\r\n\r\nWhilst this is challenging for traditional journalism rooted in the news values of proximity, immediacy, negativity, and sensationalism, FASTLab is committed to working with media companies in Australia and internationally to expand its role and in doing so its potential relevance in society by helping news organisations reimagine how they might actively contribute to the sustainable transformation of society. We know this is possible without compromising commitment to the pursuit of truth whilst offering media companies a chance to renew its social licence with the public.\r\n<h2>but not only...</h2>\r\nFASTlab was created to explore the potential of human emotion, happiness and play, open doors for non-traditional collaborators, and commercialise lateral thinking.\u00a0 Unique in Australia, we are a translational research hub, specialising in providing opportunities for community and industry partners to participate in research projects that provide tangible outcomes and solutions to real-world problems quickly.\r\n\r\nOur work so far demonstrates that all organisations - social enterprises, for profit businesses or government departments - can benefit from FASTLab\u2019s unique ethos.\r\n\r\nOur research brings together academics, practitioners and industry partners from a range of different fields. We work jointly to develop and use novel conceptual and methodological approaches that leverage discipline-specific perspectives, theories, methods, and translational strategies that deliver innovative responses to real world problems.\r\n\r\n<img class=\" wp-image-15701 aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2022/02/FastLab-Oz-300x224.jpg\" alt=\"\" width=\"360\" height=\"269\" />\r\n\r\nWe do this from our home in \u2018Q\u2019 building on the quayside of Newcastle\u2019s Honeysuckle Drive. Built using\u00a0sustainably\u00a0sourced, cross-laminated\u00a0timber, the facility is encased in 344 Sage thermal glass panels \u2013 the largest installation of this highly technical and environmentally friendly material in the southern hemisphere. Its open structure enables a fluid exchange of ideas across a porous space. Interactive displays and monitors dotted throughout enable FASTLab to expand collaboration beyond its glass shell to visitors, colleagues, and the wider community. It\u2019s a space that embodies our vision of how to do \u2018R&amp;D\u2019 without the usual physical boundaries and with brilliant facilities to workshop, invent, create and make.\r\n\r\nWe have been building a vibrant culture of \u2018learning by doing\u2019 creating several pathways for organisations, researchers and creatives to engage with us and each other. Working with external research partners using our own blended learning model we\u2019ve developed a low-cost series of concentrated learning events that enable students and researchers to see the positive impact that they are making through research and development. Our approach ensures they are part of a process of change as well as developing their learning and experience.\r\n\r\n<img class=\" wp-image-15702 aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2022/02/FL-Oz-2-300x169.jpg\" alt=\"\" width=\"357\" height=\"201\" />\r\n\r\nDelivering change needs skills in empathy. Our researchers and our students develop their abilities to work across sectors and cultures bringing different perspectives as they build relationships and plan workshop interactions that support change. We understand the need to include communities, stakeholders and wider audiences in change using creative communication skills to engage and influence them in the process.\r\n\r\nThe Clyde Street Precinct offers a grounded example of how we are helping to make this happen locally by adopting a \u2018bottom-up\u2019 approach to the development of a creative ecosystem within which artists maintain a thriving, sustainable practice, and citizens are imbricated as co-creators of community facilities and liveable city landscapes. The Clyde Street Precinct is a large industrial warehouse complex close to the University of Newcastle\u2019s City and Callaghan campuses. The previously abandoned site now accommodates 65 artists and creative practitioners drawn from across the broad range of creative industries, such as jewellery and fashion design, music recording and production, fabrication, multi-media, performing and visual arts, design and illustration, lead lighting, bookbinding, stone masonry, film, technology and experimental electronic art. The organic development of this ecosystem, with artists working alongside waste rescue not-for-profit organisations and car hire businesses, has ensured an innovative and sustainable example of a \u2018creative economy\u2019. While the cultural and geopolitical context of is localised to FASTLab\u2019s Australian home city of Newcastle, this area\u2019s evolution from a coal-port towards a cosmopolitan city is part of a broader trend of industrial towns navigating their own progression towards thriving, liveable cities.\r\n\r\n&nbsp;\r\n\r\n<strong><img class=\" wp-image-15703 aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2022/02/FL-Oz3-300x225.jpg\" alt=\"\" width=\"405\" height=\"304\" /></strong>\r\n\r\n&nbsp;\r\n<h2>Partnering in research with real-world impact:</h2>\r\nIn a post-industrial era, competition is not just about the pursuit of efficiency. Attaining sustainable economic growth and balanced social and environmental development needs a paradigm shift on how businesses, government and NGOs can create value through creativity and innovation. This level of innovation involves breaking free from conventional thinking about what kind of researchers should be involved in problem solving particular issues.\r\n\r\nFASTLab is committed to research that delivers real world impact. We work with companies and organisations on live project briefs developed to address a business need. Of course, every sector harbours the pretence that its practice is somehow \u2018special\u2019; its industry unique; the challenges it faces specific and particular to them. In that sense the media industry is no different arriving with the same preconceptions common across all businesses. Most are not expecting researchers to create prototype media products modelling and measuring human responses to them; they are unprepared for the creative industries student teams charged with quickly assessing the viability of a proposed project; they\u2019re not ready to receive the insights from digital natives critiquing their current offerings. And they are certainly not thinking they might benefit from working directly in partnership with researchers who quickly demonstrate that what they do and the way that they do it adds value. And Australia is not alone in offering companies tax incentives for engaging university academics like those in our FASTLab team in Research and Development projects.\r\n\r\nOur research focuses on human centred interactions.\u00a0 It harnesses human imagination, empathy, cooperation, co-design, design thinking, visualization, playfulness and creativity. It enables a better understanding of the underlying systems of creativity, and motivations of humans. It provides new opportunities to respond to some of our most important challenges \u2013 like healthcare.\r\n\r\nWe know that healthcare costs are rapidly rising globally due to ageing populations, the increasing prevalence of chronic diseases, improved survival rates from acute trauma, rising treatment costs, and the widening gap in access to care between rural and urban communities. Healthcare costs in Australia alone are forecast to reach $36 billion by 2028.\r\n\r\nLed by colleagues at the University of New South Wales, FASTLab is a lead research partner on a $24m Australian Research Council Hub For Connected Sensors. Our role is to co-design thinking with analytical rigor that enables the Hub team to get to creative new medical products and services quickly. Working across the Hub, our work is to design for humans and develop the next\u2010generation ultra\u2010lightweight and soft wearable medical sensor devices.\r\n\r\nWhether working with communities, industry, NGO\u2019s or governments the FASTLab team knows that imagination is the foundation of creativity and innovation. Our experience, expertise and work with our partners and clients continues to demonstrate that we can all imagine \u2018better\u2019 \u2013 and once we have, we can change things so they are. Better for all of us and for the planet we\u2019re custodians of.\r\n\r\n&nbsp;\r\n<h2>CONTACT POINT:</h2>\r\n<em>If you are interested in helping your organisation actively contribute to the sustainable transformation of society \u2013 or you\u2019d just like to learn a little more about FASTLab Thinking you can contact me directly at:</em>\r\n\r\n&nbsp;\r\n\r\n<a href=\"mailto:Paul.egglestone@newcastle.edu.au\">Paul.egglestone@newcastle.edu.au</a>\r\n\r\nT: +61 2 4985 4545\r\nM: +61 (0) 408 547 992\r\n\r\n<a href=\"https://fastlab.soci.org.au\">https://fastlab.soci.org.au</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_column_text]\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>[/vc_column_text][/vc_column][/vc_row]","post_title":"FASTlab: Future Arts, Science and Technology Laboratory","post_link":"https://media-innovation.news/media-lab/fastlab-future-arts-science-and-technology-laboratory/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"FASTlab: Future Arts, Science and Technology Laboratory\" width=\"300\" height=\"224\" src=\"https://media-innovation.news/wp-content/uploads/2022/02/FastLab-Oz-300x224.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"academic Lab, academic research, industry collaboration, multidisciplinary","%_edit_lock%":"1652360652:933","%_edit_last%":"933","%slide_template%":"","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Newcastle NSW, Australia","%_wpgmp_location_city%":"Newcastle","%_wpgmp_location_state%":"New South Wales","%_wpgmp_location_country%":"Australia","%_wpgmp_metabox_latitude%":"-32.9282712","%_wpgmp_metabox_longitude%":"151.7816802","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"8","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"15701","taxonomy=category":"Media labs","taxonomy=post_tag":"academic Lab, academic research, industry collaboration, multidisciplinary"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15699,"infowindow_disable":false},{"source":"post","title":"Der Tagesspiegel: interdisciplinary and audience-engaged innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Der Tagesspiegel: interdisciplinary and audience-engaged innovation\" width=\"300\" height=\"118\" src=\"https://media-innovation.news/wp-content/uploads/2021/10/TS-mauer-300x118.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Der Tagesspiegel: interdisciplinary and audience-engaged innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/der-tagesspiegel-interdisciplinary-and-audience-engaged-innovation/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","address":"Askanischer Pl. 3, 10963 Berlin, Germany","location":{"lat":"52.5044348","city":"Kreisfreie Stadt Berlin","state":"Berlin","country":"Germany","lng":"13.3808474","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/der-tagesspiegel-interdisciplinary-and-audience-engaged-innovation/","zoom":2,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1><strong>Der Tagesspiegel: interdisciplinary and audience-engaged innovation </strong></h1>\r\n<h3>Der Tagesspiegel\u2019s Innovation Lab is a hub for interdisciplinary collaboration - producing projects spanning sensor journalism, data visualisation and interactive, immersive storytelling.</h3>\r\nLed by Hendrik Lehmann, the Lab emerged from a series of individual data journalism projects, \u00a0and has expanded to produce a range of storytelling and platforms innovations for Der Tagesspiegel\u2019s newsroom operations.\r\n\r\nTheir work is founded on interdisciplinary collaboration: uniting data analysis, visual and immersive journalism, urban sociology and science journalism to create multiple projects. Lehmann describes the Innovation Lab as open and engaged with partners. These range across NGOs, universities, other publishers, audiences and citizens. Many projects collaborate with Der Tagesspiegel\u2019s readers to enable or further the storytelling, ensuring the lab is \u2018reader engaged\u2019 and co-opts citizens into the journalism it creates.\r\n\r\nSince starting with an emphasis on data journalism, the lab has expanded to explore a growing range of topics and approaches. Now classed as a news department it its own right, it has a core staff of five people, but Lehmann suggests this number moves and shifts depending on the projects the team is working on. \u00a0For example, external funding helps to boost the specialist skills in the lab when they\u2019re required.<strong>\u00a0</strong>\r\n<h3><strong>Notable projects </strong></h3>\r\nAlthough the lab was initially launched in 2019, several members of the team completed a number of high profile and award-winning projects from 2016 onwards. Lehmann highlights two that showcase the aspirations and achievements of the Innovation Lab - the award-winning data / cycling project Radmesser and the investigation Wem geh\u00f6rt Berlin?\r\n\r\nThat\u2019s not really true unfortunately. \u201eemerged out of a series of individual data journalism projects\u201c\r\n\r\n&nbsp;\r\n\r\n<img class=\"alignnone wp-image-15626 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2021/10/radmesser.png\" alt=\"\" width=\"1384\" height=\"785\" />\r\n\r\n<strong><em>Radmesser</em></strong><em>: creating a new storytelling approach to Berlin\u2019s cycling system, Radmesser provides interactive content underpinned by data. Audiences navigate and interact with the rich multimedia content. Insights include specific danger areas for cyclists \u2013 such as streets where cars pass most closely to cyclists. A key element of the project was to work with audiences to create \u2018swarm intelligence\u2019, where users became data collectors. Some 2,500 people volunteered for the project, with 100 people taking sensors and using them. They tracked city routes and their experiences of safety while riding around the city. Radmesser also looked at solutions \u2013 what can Berlin learn from cities such as Copenhagen.\u00a0</em>\r\n\r\n&nbsp;\r\n\r\n<em><img class=\"alignnone size-large wp-image-15627\" src=\"https://media-innovation.news/wp-content/uploads/2021/10/Gehort-Berlin-1024x626.png\" alt=\"\" width=\"1024\" height=\"626\" /></em>\r\n\r\n<strong><em>Wem geh\u00f6rt Berlin</em></strong><em>?: Working with an engaged audience and in cooperation with independent and non-for-profit research centre CORRECTIV, and a range of partners, Wem geh\u00f6rt Berlin? explores property ownership throughout the city. It asks which property owners have a significant impact on the housing market and which owners potentially act illegally or questionably? Audiences engaged with the project through completing surveys, and the piece created a range of interactive content exploring the emergent market, ownership structure and how 12 housing companies own 250,000 apartments throughout the city. Interestingly, six of these companies are public companies who share the same investors. The investigation continued beyond the lab as CORRECTIV continued to work with new local media partners. </em>\r\n\r\n&nbsp;\r\n\r\n<img class=\"alignnone size-full wp-image-15628\" src=\"https://media-innovation.news/wp-content/uploads/2021/10/Cities-4-rent.png\" alt=\"\" width=\"1384\" height=\"922\" />\r\n\r\n<strong><em>Cities 4 Rent</em></strong><em>: Continued as a follow-up to<strong> Wem geh\u00f6rt Berlin?.</strong> \u00a0The investigation, conducted two years after the initial project, crossed 16 cities across Europe, some of which are still yet to report. Lehmann explains that the Lab had a further role to create a harmonised visual identity within this project that would be shared between all the partners. The project tracked the rising investments, costs of living and how the investment\u2013rental cycle is making cities increasingly unaffordable. </em>\r\n\r\nBeyond these two projects, the lab engages in a <a href=\"https://interaktiv.tagesspiegel.de/\">variety of work</a> spanning immersive and interactive content. In exploring these platforms, each combining data, data visualisations and rich media, the Innovation Lab has generated its own code base for \u2018linear\u2019 content.\r\n\r\nLehmann explains it \u201cbecame one of our main [activities]; to develop our own kind of code base for linear storytelling that a CMS can't do\u201d. In this way the lab has a \u201cforerunner function because we can do things that no one can do already with the regular CMS.\u201d He adds this approach has an \u2018empowering\u2019 effect for some in the newsroom, allowing journalism in new ways.\r\n<h3><strong>Interdisciplinary capacity for innovation </strong></h3>\r\nTo create these pieces, and the data that underpins them, the Lab has a small group of five staff who bring a range of skills to the innovation work. These include multimedia storytelling, data analysis, coding and design. But Lehmann describes this team as flexible, expanding to pull in different ranges of expertise depending on the project\u2019s requirements and available funding.\r\n\r\nThis approach also takes advantage of relationships with a range of partners across not-for-profit organisations and universities. These collaborations both inspire new ideas and help to deliver projects that make it beyond the concept or funding stage.\r\n\r\n<img class=\"alignnone size-full wp-image-15629\" src=\"https://media-innovation.news/wp-content/uploads/2021/10/TS-pic-4.png\" alt=\"\" width=\"1384\" height=\"1216\" />\r\n\r\n&nbsp;\r\n<h3><strong>Innovation in the time of Covid </strong></h3>\r\nThe Covid 19 pandemic consumed much of the lab\u2019s time. Lehmann suggests the data work conducted by the lab has placed it squarely within the operations of Der Tagesspiegel\u2019s newsroom. This work has ranged from creating data-driven pieces and visualisations on the pandemic as it has unfolded, but also in providing essential services to the editorial teams more broadly.\r\n\r\nLehmann explains: \u201cCovid [saw us] become part of the core of the newsroom\u2026 Everyone needs to get data every day. So, we developed an internal tool that just allows the print editors to export graphics that are live at the time they need them and the same format\u2026 so [this] has really pushed us to the core of the newsroom\u201d.\r\n\r\nA further element to the lab is how it\u2019s building up knowledge and experience through the projects it runs. Lehman suggests that over time, these learnings \u2013 from both successful and unsuccessful projects - flow into future activities. For example, a project using augmented reality to explore German re-unification provided insights into AR tech, that Lehmann feels can be deployed in projects that utilise augmented reality in the future. These insights also spanned commercial concerns, such as how AR could generate revenue streams.\r\n<h3><strong>What next?</strong></h3>\r\nLooking to the future, Lehmann suggests that the Lab will continue to work on some of the key areas it\u2019s developed over recent years as such urban planning, residential ownership, traffic, social networks and to engage readers to help them tell the stories they cover.\r\n\r\n\u201cUrban traffic, the mobility revolution, housing. Because it's going to be a new expression of our times.\u201d\r\n\r\nNew projects involving climate change and policy in Africa, machine learning and to focus on advanced data analysis and visualisation.\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n<img class=\"alignnone size-medium wp-image-15630\" src=\"https://media-innovation.news/wp-content/uploads/2021/10/hendrik_lehmann-300x200.jpg\" alt=\"\" width=\"300\" height=\"200\" />\r\n\r\nHendrik Lehmann, head of Der Tagesspiegel Innovation Lab\r\n\r\nTwitter: <a href=\"https://twitter.com/plateauton\">@plateauton</a>\r\n\r\n&nbsp;\r\n\r\n&nbsp;\r\n\r\n&nbsp;\r\n\r\n<a href=\"https://twitter.com/blacktarmac\" target=\"_blank\" rel=\"noopener\">\u200f</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Der Tagesspiegel: interdisciplinary and audience-engaged innovation","post_link":"https://media-innovation.news/media-lab/der-tagesspiegel-interdisciplinary-and-audience-engaged-innovation/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Der Tagesspiegel: interdisciplinary and audience-engaged innovation\" width=\"300\" height=\"118\" src=\"https://media-innovation.news/wp-content/uploads/2021/10/TS-mauer-300x118.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"","%_edit_lock%":"1646066184:4","%_edit_last%":"4","%_oembed_8d8201f227c34e7854c55c96f99a6ff3%":"{{unknown}}","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Askanischer Pl. 3, 10963 Berlin, Germany","%_wpgmp_location_city%":"Kreisfreie Stadt Berlin","%_wpgmp_location_state%":"Berlin","%_wpgmp_location_country%":"Germany","%_wpgmp_metabox_latitude%":"52.5044348","%_wpgmp_metabox_longitude%":"13.3808474","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"15633","taxonomy=category":"Media labs","taxonomy=post_tag":""},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15625,"infowindow_disable":false},{"source":"post","title":"Future Media Hubs: building a media innovation network in the heart of Europe","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Future Media Hubs: building a media innovation network in the heart of Europe\" width=\"300\" height=\"100\" src=\"https://media-innovation.news/wp-content/uploads/2021/08/1500x500-300x100.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Future Media Hubs: building a media innovation network in the heart of Europe</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            An international network of sandboxes, innovation labs and accelerators allows its media organisation members to exchange learnings from their innovation projects and make connections with the startup ecosystem.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/future-media-hubs-building-a-media-innovation-network-in-the-heart-of-europe/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"An international network of sandboxes, innovation labs and accelerators allows its media organisation members to exchange learnings from their innovation projects and make connections with the startup ecosystem.","address":"Brussels, Belgium","location":{"lat":"50.8503396","city":"Brussels","state":"Brussels","country":"Belgium","lng":"4.3517103","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/future-media-hubs-building-a-media-innovation-network-in-the-heart-of-europe/","zoom":2,"extra_fields":{"post_excerpt":"An international network of sandboxes, innovation labs and accelerators allows its media organisation members to exchange learnings from their innovation projects and make connections with the startup ecosystem.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Future Media Hubs: building a media innovation network in the heart of Europe</h1>\r\n<strong>An international network of sandboxes, innovation labs and accelerators allows its media organisation members to exchange learnings from their innovation projects and make connections with the startup ecosystem.</strong>\r\n<ul>\r\n \t<li><strong>The Future Media Hubs is a group of communities that connect media companies across Europe, helping them gain new expertise by sharing insights.</strong></li>\r\n \t<li><strong>The network is also closely connected to the media startup scene and facilitates collaborations between media organisations and startups.</strong></li>\r\n \t<li><strong>In the future, Future Media Hubs aims to expand its network also outside Europe, and plans to build a centre for media innovation in the heart of Brussels.</strong></li>\r\n</ul>\r\nMedia companies are increasingly sharing learnings with one another, but this knowledge-sharing process tends to happen on an ad-hoc basis. Moreover, many media organisations see great potential in collaborating with startups, but the venues where the two worlds can connect are rare.\r\n\r\nThis is the gap that the <a href=\"https://futuremediahubs.com/\">Future Media Hubs</a> aims to fill. The Brussels-based initiative is building a platform that offers systematic opportunities for media labs, sandboxes and accelerators to share insights and set up new collaborations.\r\n\r\n\u201cWe want to boost innovation within Europe and accelerate the development of the media industry by connecting its different actors together,\u201d says Sarah Geeroms, Head of Future Media Hubs.\r\n<h3>From a small community to a group of hubs</h3>\r\nThe road to the Future Media Hubs started within the EU Horizon 2020 project <a href=\"https://www.mediaroad.eu/\">MediaRoad</a>, which set up a small international community of media companies with the goal of strengthening their collaborations with startups.\r\n\r\nMediaRoad ended in 2019, but the feedback from the participants was so positive that VRT, the Dutch-language public broadcaster in Belgium, decided to maintain and expand the community, titled <strong>Sandbox Hub</strong>. Soon after, RTBF, Belgium\u2019s French-language public broadcaster, also joined to collaborate on the initiative.\r\n\r\nInitially a group of public media companies, today Sandbox Hub also welcomes commercial companies as its members. It has over 20 members at the moment, and the split between public and commercial firms is close to 50\u201350.\r\n\r\nSandbox Hub, however, was only the beginning. In the spring of 2020, a parallel network called <strong>Video Snackbar Hub</strong> was launched, focusing on innovative content creation especially with regard to video streaming.\r\n\r\nSoon after, <strong>Open Labs Hub</strong> was also launched, aiming to support arising talents in the media industry and nurture the development of digital skills. Finally, <strong>Game Hub</strong>, which connects gaming and esports experts, was added in March 2021 to the Future Media Hubs\u2019s portfolio of communities.\r\n\r\n\u201cWe never had the ambition to build a group of hubs,\u201d says Geeroms. \u201cWe just grew into that because there was so much interest. We could see that there were so many people working on innovation, but they didn't know the right people in other media organisations.\u201d\r\n<h3>Learning through exchange and sharing</h3>\r\nThese communities enable the participating media companies to share learnings, mainly through the member-exclusive monthly calls. These include a short roundtable about the most recent projects and experiences among the members, followed by more focused presentations on specific topics. An external speaker might also join to discuss an issue that is of particular interest to the group.\r\n\r\nEach meeting is recorded and documented, and the materials are shared with the community members. A dedicated Slack channel is also available for media companies to request information, share solutions and highlight interesting events.\r\n\r\nGeeroms points out that there are clear advantages that come from knowledge sharing: \u201cIt's only by exchanging experiences that you find knowledge and relevant insights for your organisation. If you don't share yourself, you don't get anything back.\u201d\r\n\r\nEmbracing that mindset can take time however, and Geeroms says that in the beginning many companies \u2013 especially in commercial media \u2013 were hesitant about sharing information with organisations that they traditionally consider their competitors.\r\n\r\n\u201cWe say that we can compete on content, but we need to collaborate or at least exchange on technology, because we're all small and too local if we want to succeed and survive. Otherwise we will be eaten by the Googles and the Facebooks.\u201d\r\n\r\nAlthough public and commercial media companies can have different points of view, Geeroms emphasises that the two worlds can have very fruitful exchanges and partnerships: \u201cYou just need to look and concentrate on the win-win.\u201d\r\n<h3>Problem-solving through collaborations with startups</h3>\r\nIn addition to knowledge sharing, the Future Media Hubs also aims to help media companies engage more effectively with the startup ecosystem. For instance, it collects information about startups that have on-going projects with the community\u2019s media organisation members, and documents learnings from those collaborations, Geeroms explains. \u201cSo as a member you have a clear view on European startups that are actually working with media organisations.\u201d\r\n\r\nBefore the pandemic ended physical events, the Sandbox Hub also organised events where startups could pitch their solutions to the Hub\u2019s members. To help similar connections take place virtually, the Hub is now in the process of collecting information from media companies about their current challenges and issues that startups might be able to help them with.\r\n\r\n\u201cThe fact that we start from a problem, something they're having difficulties with, allows us to be more successful,\u201d Geeroms says. \u201cWe're looking for solutions, for things they are struggling with, and if we find them, we can really help them go forward in their transformation process.\u201d\r\n\r\nThe Future Media Hubs is also part of two EU funded projects, <a href=\"https://mediamotoreurope.eu/\">MediaMotorEurope</a> and <a href=\"https://www.stadiem.eu/\">STADIEM</a>, which help startups scale through its coaching and funding programmes, while tackling media challenges and introducing emerging technologies in the media and creative sector.\r\n<h3>Building in and outside Europe</h3>\r\nThe Future Media Hubs\u2019s long-term plan is to strengthen its role in Europe by creating a centre for media innovation in Brussels. The construction of the <a href=\"http://mediapark.brussels/\">Mediapark.Brussels</a> cluster is underway, and when finished it will house over 60 media companies and 5,000 professionals close to European institutions. The Future Media Hubs will also most likely be included, giving it a front-seat view to the European news media scene.\r\n\r\nGeeroms says the network also hopes to expand outside Europe in the future: \u201cWe believe that if you want to have a strong European network, you also need to know what happens in other continents,\u201d she says. \u201cWe're making the first connections and seeing what opportunities there are.\u201d\r\n\r\nWhen travelling stopped, this naturally hindered the Hub\u2019s ambitions, both in and outside Europe: \u201cWe usually invite new members to come to Brussels and see how we work. Not being able to do that means the dynamic in the group is very different. New people are sometimes more reserved in speaking, but if they had met during a trip, the dynamic would be completely different.\u201d\r\n\r\nThis experience has brought home the importance of the casual chats that happen during physical events, Geeroms says: \u201cI\u2019ve learned that those informal conversations are very important. If you invest in those, it will help make sure that the formal conversations are also more successful.\u201d\r\n\r\n--\r\n\r\nCONTACT\r\n<img class=\"alignnone wp-image-15614 size-thumbnail\" src=\"https://media-innovation.news/wp-content/uploads/2021/08/SarahGeeroms15_0-150x150.jpg\" alt=\"\" width=\"150\" height=\"150\" />\r\nSarah Geeroms, Partnerships &amp; Head of Future Media Hubs, VRT\r\nLinkedIn: <a href=\"https://www.linkedin.com/in/sarahgeeroms/\">Sarah Geeroms</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Future Media Hubs: building a media innovation network in the heart of Europe","post_link":"https://media-innovation.news/media-lab/future-media-hubs-building-a-media-innovation-network-in-the-heart-of-europe/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Future Media Hubs: building a media innovation network in the heart of Europe\" width=\"300\" height=\"100\" src=\"https://media-innovation.news/wp-content/uploads/2021/08/1500x500-300x100.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"","%_edit_lock%":"1634896834:4","%_edit_last%":"931","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"15615","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Brussels, Belgium","%_wpgmp_location_city%":"Brussels","%_wpgmp_location_state%":"Brussels","%_wpgmp_location_country%":"Belgium","%_wpgmp_metabox_latitude%":"50.8503396","%_wpgmp_metabox_longitude%":"4.3517103","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"6","taxonomy=category":"Media labs","taxonomy=post_tag":""},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15613,"infowindow_disable":false},{"source":"post","title":"Alliance Presse: balancing economic and environmental success in the French press","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The blue image with white writing explains (in French) the Alliance Presse&#039;s environmental commitment, it says: Ecological transition and advertising - the news press continues its commitment\" width=\"300\" height=\"100\" src=\"https://media-innovation.news/wp-content/uploads/2021/06/Alliance-de-la-Presse-dInformation-Ge\u0301ne\u0301rales-ecological-transition-campaign-wide-v3-300x100.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Green media, Innovation Case</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Alliance Presse: balancing economic and environmental success in the French press</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Alliance Presse has made a four-point commitment to tackle environmental issues \u2013 focussed on concerns about advertising.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/alliance-presse/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Alliance Presse has made a four-point commitment to tackle environmental issues \u2013 focussed on concerns about advertising.","address":"69 Rue du Chevaleret, 75013 Paris, France","location":{"lat":"48.82849189999999","city":"Paris","state":"\u00cele-de-France","country":"France","lng":"2.376216599999999","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/alliance-presse/","zoom":2,"extra_fields":{"post_excerpt":"Alliance Presse has made a four-point commitment to tackle environmental issues \u2013 focussed on concerns about advertising.","post_content":"[vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1>Alliance Presse: balancing economic and environmental success in the French press</h1>\r\n<span style=\"font-weight: 400;\">Because it\u2019s seen as performing a vital role for democracy, France\u2019s \u2018information press\u2019 has special rights\u00a0 \u2013 lighter taxes, low tariffs for postal distribution, guaranteed space in newsstands and direct funding from the state.</span>\r\n\r\n<span style=\"font-weight: 400;\">But, as ever, those rights come with responsibilities \u2013 and right now, the organisation that represents some 300 publishers across the country \u2013 is working out how to tackle those relating to environmental sustainability.</span>\r\n\r\n<span style=\"font-weight: 400;\">Pierre Petillault is the director general of the Alliance de la Presse d'Information G\u00e9n\u00e9rale. He explains that the press in France has for a number of years been obliged to support an \u2018eco-contribution system\u2019 to help mitigate its paper waste.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBasically you have, as an industry, to fund the recycling of your waste,\u201d Petillault explains. \u201cAnd for a newspaper, it's paper. We have to fund a specific company, it's more or less an association working as a company, which organises the recycling of papers in cities.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd, also, we have to help the public become more conscious of the necessity of recycling.\u201d\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">The Alliance Presse membership funds <a href=\"https://www.citeo.com/\">CITEO</a> with upwards of \u20ac22 million per year, mainly via advertisements about recycling.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe run their ads to the public saying, \u2018you've got to recycle paper. Be careful, you've got to put it in the yellow bin\u2019 and these kinds of things. Some of the messages are very general. Some of them are really focussed on recycling paper.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe have a lot of other specific legislative obligations and, among them, we have to use recycled paper, at different levels, depending on the kind of publication. For instance, magazines can\u2019t use the same amount of recycled paper as we do with a daily newspaper.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe have to stop using plastic covers, beginning in 2022, stop using mineral inks beginning in 2023 and we also have to gradually raise the rates of recycled paper.\u201d</span>\r\n<h3><span style=\"font-weight: 400;\">Advertising issues</span></h3>\r\n<span style=\"font-weight: 400;\">In March 2021, the organisation Petillault leads made a new, <a href=\"https://www.alliancepresse.fr/actualite/transition-ecologique-et-publicite-la-presse-dinformation-poursuit-son-engagement/\">four-point commitment</a> to \u2018ecological transition\u2019, particularly related to advertising.</span>\r\n\r\n<span style=\"font-weight: 400;\">This has been spurred on by the <a href=\"https://www.nytimes.com/2021/05/19/business/macron-france-climate-bill.html\">wide-ranging environmental bill</a> going through the French parliament, which contains several clauses designed to limit the harmful effects of this part of the media industry.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe commitments we\u2019ve made are really focused on advertising because that's a debate right now in France. There is a strong current advocating for forbidding some industries from advertising, namely cars, airlines, this kind of thing.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI remember the discussions we had with French policymakers and we told them, \u2018you can suppress advertising, but you won\u2019t suppress the need for a car, for instance. And they said \u2018French don't need a car\u2019. And we answered 'even outside Paris?\u2019. So they said, \u2018oh, yeah, okay, outside Paris... maybe\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo the fact that you don't need a car, you don't need advertising, you don't need anything, that\u2019s a view that is detached from reality. We\u2019re taking things by the wrong end, advertising is at the end of the chain. You can suppress advertising, but people will need cars. The point is to give them cars that do not pollute.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBut in France this idea is quite popular,\u201d he adds, \u201cbanning some adverts, some industries from advertising.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Of course for publishers, advertising represents a significant proportion of revenues \u2013 an average of 35 percent across the Alliance Presse membership \u2013 he explains.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo of course, publishers are not really okay with this. Some of them, the smallest ones, heavily rely on advertising \u2013 and especially car advertising \u2013 to fund themselves.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThey're already, frankly speaking, in bad shape economically. In the last 10 years, advertising revenues were cut by half for newspapers, which is not the case for TV or radio. And so forbidding even more advertising, is very, very, very worrying for some of them.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo what we're trying to do is to make it understood that, \u2018OK, advertising is maybe not the best thing in the world, but it's absolutely necessary to fund newspapers\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe never saw newspapers having a functioning business model without advertising.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Petillault, inevitably, relates some of these issues back to social media giants.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI see everywhere people saying, \u2018you don't need advertising, that's not for you, rely on subscriptions. That's good money, online subscriptions\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cActually, there is an agenda behind this, which is \u2018let's keep all the advertising money for Google and Facebook\u2019. We have these big platforms trying to, let's say, push us out of online advertising, and trying </span><i><span style=\"font-weight: 400;\">and succeedin</span></i><span style=\"font-weight: 400;\">g in getting all the value.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe're very happy to sell online subscriptions, but we sell it at a rate that is three times less than in the paper world and, yet, the journalist that wrote the article is paid the same. So the cost is the same, but the revenue is not the same. And so we can't afford to get rid of advertising right now. Really not.\u201d</span>\r\n<h3><span style=\"font-weight: 400;\">Making the transition</span></h3>\r\n<span style=\"font-weight: 400;\">As part of its plan, the Alliance Presse has committed to reviewing ads for their environmental credentials, quantifying its membership's environmental coverage, training advertising execs on this and supporting those who take the environment seriously, particularly through an award with publicity prizes.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe are already self-regulating advertising, with the support of the <a href=\"https://www.aacc.fr/\">AACC</a>, a professional association for media advertisement, advertising agencies and so on, which has been self-regulating advertisements for at least a decade.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd so we will look at every ad before publication and, if needed, tell the AACC to check what is said in the ads regarding environmental issues. That means not using environmental arguments if they\u2019re not true or not justified. And on the other end, not running ads that are clearly, let's say, \u2018anti-environment\u2019.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThere is also a commitment to train people about advertising, press and the environment, and this is targeted to advertising professionals. We are working with the ACPM, which is a certification agency for press and media in France, to include in our Tomorrow's Press programme a specific module for press and the environment.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Perhaps the most challenging of the four activities is designed to help the press prove its worth here \u2013 putting meaningful number on its environmental reporting \u2013 and it's perhaps a perverse result of the journalism done here that French people are concerned about the impact of advertising.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cShowing that we need this money to live and to carry on is easy, but showing that we bring a valuable contribution to the public debate is not so easy,\u201d Petillault acknowledges. \u201cAnd that\u2019s what we\u2019re trying to do.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe want to be able to say \u2018okay, we know that it's several hundreds of articles about environmental issues per day\u2019. So we're trying to get a number and then to use that number, to show the value we bring.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cNewspapers are one of the main channels to communicate and to influence the public on environmental issues and to be realistic, in the past decade, most of this work was done, especially, by the information press.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe contributed a lot to raise these issues. And now we have these policymakers turning to us and saying, \u2018okay, you won't be able to do advertising for cars anymore and we say, \u2018okay, let's regulate car selling if this is a problem, but not advertising. This makes no sense\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo what we want to show is that we can be virtuous on advertising, even for polluting products, and that we try to be objective about what we bring in terms of environmental consciousness.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">The Alliance has also created a corporate social responsibility working group so it can understand how publishers are already doing in this area, including looking at the industry\u2019s carbon footprint. The former telecoms executive says some of them are very advanced, but some are not at all, which is why they aren\u2019t currently going to be tackling digital.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cFirst of all, we don't generate value through smartphones or Wi-Fi themselves,\u201d he explains. \u201cSome of our newspapers are very digitalised, but that's the case of usually the big national newspapers, for instance, Le Monde has most of its subscribers through digital right now.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBut that's absolutely not the case with most of our members \u2013 the smallest newspapers, especially the more than 200 regional weekly newspapers \u2013 some of them have almost no digital footprint. Our economy is still mainly based on paper.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cFrom this group, we will share what is doable by the majority of them and one of the work streams we have is the environmental footprint. But we are at the beginning.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">CONTACT</span>\r\n\r\n<span style=\"font-weight: 400;\">Pierre Petillault, Director General at Alliance de la Presse d'Information G\u00e9n\u00e9rale</span>\r\n\r\n<span style=\"font-weight: 400;\">Twitter:</span> <a href=\"https://twitter.com/ppetillault?lang=en\"><span style=\"font-weight: 400;\">@PPetillault</span></a>[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"Alliance Presse: balancing economic and environmental success in the French press","post_link":"https://media-innovation.news/media-lab/alliance-presse/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The blue image with white writing explains (in French) the Alliance Presse&#039;s environmental commitment, it says: Ecological transition and advertising - the news press continues its commitment\" width=\"300\" height=\"100\" src=\"https://media-innovation.news/wp-content/uploads/2021/06/Alliance-de-la-Presse-dInformation-Ge\u0301ne\u0301rales-ecological-transition-campaign-wide-v3-300x100.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Green media, Innovation Case","post_tags":"AACC, ACPM, Advertising, Alliance de la Presse d'Information G\u00e9n\u00e9rale, Alliance Presse, Brainprint, CITEO, Climate bill, Corporate social responsibility, Pierre Petillault, Recycling","%_edit_lock%":"1661262462:933","%_edit_last%":"933","%_thumbnail_id%":"15609","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"69 Rue du Chevaleret, 75013 Paris, France","%_wpgmp_location_city%":"Paris","%_wpgmp_location_state%":"\u00cele-de-France","%_wpgmp_location_country%":"France","%_wpgmp_metabox_latitude%":"48.82849189999999","%_wpgmp_metabox_longitude%":"2.376216599999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_focuskw%":"Alliance Presse","%_yoast_wpseo_title%":"Alliance Presse: balancing economics and the environment in French news","%_yoast_wpseo_metadesc%":"Alliance Presse has made a four-point commitment to tackle environmental issues \u2013 focussed on concerns about advertising.","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_wpseo_primary_category%":"69","%twitter_share%":"Alliance Presse: balancing economics and the environment in French news","%twitter_card%":"Alliance Presse: balancing economics and the environment in French new","%_yoast_wpseo_opengraph-title%":"Alliance Presse: balancing economics and the environment in French news","%_yoast_wpseo_opengraph-image%":"https://media-innovation.news/wp-content/uploads/2021/01/Screen-Shot-2021-06-21-at-10.52.56.png","%_yoast_wpseo_opengraph-image-id%":"15603","%_yoast_wpseo_twitter-title%":"Alliance Presse: balancing economics and the environment in French news","%_yoast_wpseo_twitter-image%":"https://media-innovation.news/wp-content/uploads/2021/01/Screen-Shot-2021-06-21-at-10.52.56.png","%_yoast_wpseo_twitter-image-id%":"15603","taxonomy=category":"Green media, Innovation Case","taxonomy=post_tag":"AACC, ACPM, Advertising, Alliance de la Presse d'Information G\u00e9n\u00e9rale, Alliance Presse, Brainprint, CITEO, Climate bill, Corporate social responsibility, Pierre Petillault, Recycling"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15602,"infowindow_disable":false},{"source":"post","title":"BBC Future Planet: sustainable development in a solutions newsroom","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"A screenshot of the BBC Future Planet website front page, including a story about Lagos in Nigeria, which is often flooded\" width=\"300\" height=\"136\" src=\"https://media-innovation.news/wp-content/uploads/2021/01/Screen-Shot-2021-02-16-at-14.51.31-300x136.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Green media, Innovation Case</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">BBC Future Planet: sustainable development in a solutions newsroom</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            BBC Future Planet is calculating its digital footprint and cutting flying, which has cut costs and increased diversity in the newsroom.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/bbc-future-planet/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"BBC Future Planet is calculating its digital footprint and cutting flying, which has cut costs and increased diversity in the newsroom.","address":"Broadcasting House, Portland Pl, Marylebone, London W1A 1AA, UK","location":{"lat":"51.5188884","state":"England","country":"United Kingdom","lng":"-0.1439307","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/bbc-future-planet/","zoom":2,"extra_fields":{"post_excerpt":"BBC Future Planet is calculating its digital footprint and cutting flying, which has cut costs and increased diversity in the newsroom.","post_content":"[vc_row][vc_column width=\"1/4\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1><span style=\"font-weight: 400;\">BBC Future Planet: sustainable development in a solutions newsroom</span></h1>\r\n<span style=\"font-weight: 400;\">Future Planet was</span> <span style=\"font-weight: 400;\">launched in February 2020 as a new sub-site of the UK public-service broadcaster\u2019s commercial arm BBC.com.</span>\r\n\r\n<span style=\"font-weight: 400;\">It offers its global audience a \u2018solutions journalism\u2019 take on a whole planet\u2019s worth of environmental issues - whether that\u2019s the</span><a href=\"https://www.bbc.com/future/article/20210112-the-vast-bicycle-graveyards-of-china\"> <span style=\"font-weight: 400;\">pros and cons of bike-share schemes</span></a><span style=\"font-weight: 400;\"> or the</span><a href=\"https://www.bbc.com/future/article/20210119-why-saving-whales-can-help-fight-climate-change\"> <span style=\"font-weight: 400;\">contribution that whales make to controlling the temperature of the ocean</span></a><span style=\"font-weight: 400;\">.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI think people sometimes get the wrong idea about solutions journalism,\u201d explains the site\u2019s editor Martha Henriques. \u201cThey think it's about success stories or that it's about \u2018feel good\u2019 stories. Sometimes a success story is a solutions story, but that's not the whole of it at all. It's about assessing solutions in the round and finding evidence-based ways that we can tackle these crises.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Not only is there a growing body of academic literature on what is and isn\u2019t solutions journalism, and why solutions matter, but there are also organisations including the</span><a href=\"https://www.solutionsjournalism.org/\"> <span style=\"font-weight: 400;\">Solutions Journalism Network</span></a><span style=\"font-weight: 400;\"> that provide resources and training in this area.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt\u2019s essentially about audience,\u201d Henriques explains. \u201cAnd in a way, it's quite common sense. If you have a totally \u2018doom and gloom\u2019 narrative about this crisis, then it feels insurmountable, and it's just a really hard thing to engage with and is probably counterproductive. This is no longer a sort of debate about whether climate change exists\u2026 now, the important thing is what you do about it.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">And, what you do about it at Future Planet goes beyond simply seeking out the very best solutions, it\u2019s also about getting an alignment between editorial values and working practices.</span>\r\n<h3><b>Fewer flights, greater diversity</b></h3>\r\n<span style=\"font-weight: 400;\">\u201cIt might seem like a fairly small amount of emissions, sending a reporter from one country to another to cover a story, and when there's absolutely no way to it without flying, I would say the editorial justification of covering a really important environmental story would win out,\" Henriques acknowledges.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBut I think a lot of publications fall back on that crutch and that historic way of doing things, without thinking of the alternatives and of the benefits of thinking in a more sustainable way.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">By committing to trying not to fly people out from London, during a 10-month period she calculates this saw the publication cut its potential carbon usage from 26.5 tonnes, to less than half a tonne used.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThere's obviously the benefits of the emissions if you don't fly reporters around, but it gives you that extra impetus to expand your pool of writers and to work with more local reporters around the world.</span>\r\n\r\n<span style=\"font-weight: 400;\">\"And there are just so many benefits beyond carbon emissions to doing that. You surface voices that you wouldn't otherwise hear. You get a really grounded perspective, which is a vast improvement to someone being parachuted in and who only has a few days to try and get their head around the situation.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd also, especially as we\u2019re a very global publication, we see all the benefits in terms of diversity - 60 per cent of our writers on Future Planet are black or minority ethnic reporters.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd we work with a lot of reporters in the Global South. That's particularly important in terms of climate change, because, when you're writing stories about solutions that are being brought into effect on the front lines of climate change, it matters to actually have voices from those communities telling those stories.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo, you know, from the outset, there was this kind of net of benefits to thinking about sustainability in terms of our emissions and what that will also do sort of editorially for the publication. It\u2019s also more financially sustainable as well, because you can cover more stories for the same amount of budget.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">This combination of environmental, social, cultural and economic benefits </span><a href=\"https://en.unesco.org/themes/education-sustainable-development/what-is-esd/sd\"><span style=\"font-weight: 400;\">meets the very definition of sustainable development</span></a><span style=\"font-weight: 400;\"> committed to by governments and companies around the world. And Henriques believes it\u2019s also where you\u2019re likely to find innovation.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI think a lot of publications might be put off because it feels like you're putting restrictions on yourself. You're thinking,\u2018we're already extremely busy people, so how are we going to cope with this extra work of making sure we make time to network with reporters beyond our existing echo chambers?\u2019. But, I think by imposing those boundaries and challenges, you find that's the way that you will really sort of push yourself into doing something new.\u201d</span>\r\n<h3><b>Digital footprint</b></h3>\r\n<span style=\"font-weight: 400;\">Every story at Future Planet also</span><a href=\"https://www.bbc.com/future/article/20200131-why-and-how-does-future-planet-count-carbon\"> <span style=\"font-weight: 400;\">comes with an estimate of the emissions per page view,</span></a><span style=\"font-weight: 400;\"> relatively small at one to three grams, but no easy task to begin with.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOur digital carbon emissions, that's something fairly contained\u2026 [it\u2019s] the energy necessary to transfer data over the wire and the energy intensity of the appliance used and so on. But even in that system, you have to make so many assumptions, because the device that someone's using is different, and the energy intensity could be different in different parts of the world and so on.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo even with that kind of contained system, getting a good estimate is remarkably difficult.\u00a0 When we launched, I also was really keen to include structural emissions into the calculation. So, for example, our team sitting in BBC offices, \u2018what amount of power should be taken into account for that?\u2019. But it gets remarkably complicated very quickly and really difficult to quantify. So rather than give a sort of bodged estimation, we decided, as you\u2019ll</span><a href=\"https://www.bbc.com/future/article/20200131-why-and-how-does-future-planet-count-carbon\"> <span style=\"font-weight: 400;\">read in the article</span></a><span style=\"font-weight: 400;\">, there are some places where we just draw the line.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe vast majority of the writers for Future Planet are freelancers. So it would feel like a bit of an imposition to say \u2018and have you updated your device recently?\u2019. But within the staff, we do have conversations about which forms of communication, especially when we're working remotely, should we be using. \u2018Should we be sending one-line emails? How does that measure up against a Slack message or a WhatsApp message?\u2019.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">No one\u2019s solved this yet, although the</span><a href=\"https://dimpact.org/about\"> <span style=\"font-weight: 400;\">DIMPACT</span></a><span style=\"font-weight: 400;\"> team at the University of Bristol, along with 10 media organisations including the BBC, is attempting to answer some outstanding questions around the energy intensity of media consumption.</span>\r\n\r\n<span style=\"font-weight: 400;\">Another challenge many publishers have is with advertising - present on BBC.com sites when viewed from outside the UK.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe have been particularly careful, for example, not having an airline buying out our ads for a year. We need to be careful around greenwashing. The BBC has compliance guidance to make sure that any advertiser that we work with makes sense for the publication.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBut all publications face challenges around their advertisers. And I think, especially when you're covering environment journalism, the most sustainable, eco-friendly brands that are out there may not be the ones with the purchasing power for the advertising space.\u201d</span>\r\n<h3><b>Systemic change</b></h3>\r\n<span style=\"font-weight: 400;\">The solutions approach makes the site distinctive from the more straight environment features found on BBC Future, the parent site that\u2019s been doing science, health, technology and environment features for its international audience for</span><a href=\"https://www.bbc.co.uk/mediacentre/worldwide/220212future\"> <span style=\"font-weight: 400;\">almost a decade</span></a><span style=\"font-weight: 400;\">.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">It is also \u201cnot news\u201d Henriques says. \u201cOur remit is to take a step back from the news cycle and give the audience additional perspective that they might not get from the 24/7 coverage of current affairs - we look at systemic change.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo that's changes through industries and large-scale processes rather than, for example, \u2018should I buy bamboo toilet paper or sort of conventional toilet paper?\u2019.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI think, you know, if anything, COVID has shown us that taking a systemic approach, that's really the way that you are going to lead to any large-scale change in terms of climate change. You often have the idea that these really big changes to our lives lead to a big impact on the environment. But it's actually a remarkably small blip in the scheme of things.\u201d</span>\r\n<h3><b>Considering action</b></h3>\r\n<span style=\"font-weight: 400;\">Although solutions journalism, and traditional journalism, don\u2019t typically aim to get involved with the action, Henriques says that in 2021, Future Planet may take a more active role in \u2018citizen science\u2019 projects with external partners.</span>\r\n\r\n<span style=\"font-weight: 400;\">The BBC itself led the way on doing so-called \u2018sensor journalism\u2019 in its environmental reporting,</span><a href=\"http://news.bbc.co.uk/1/hi/magazine/7532603.stm\"> <span style=\"font-weight: 400;\">measuring air quality live</span></a><span style=\"font-weight: 400;\"> at the 2008 Beijing Olympics. Many more media organisations have gone on to include their audiences directly in such data collection, perhaps most notably WNYC with its</span><a href=\"https://current.org/2016/07/wnycs-latest-sensor-journalism-project-zeroes-in-on-heat-island-harlem/\"> <span style=\"font-weight: 400;\">Harlem Heat Project</span></a><span style=\"font-weight: 400;\">,</span><a href=\"https://project.wnyc.org/cicadas/\"> <span style=\"font-weight: 400;\">Cicada Tracker</span></a><span style=\"font-weight: 400;\"> and</span><a href=\"https://gothamist.com/news/climate-change-might-be-messing-up-snowflakes-as-we-know-them-but-you-can-help\"> <span style=\"font-weight: 400;\">X-Snow</span></a><span style=\"font-weight: 400;\">, all seeking to help citizens be part of the solution.</span>\r\n\r\n<span style=\"font-weight: 400;\">CONTACT</span>\r\n\r\n<span style=\"font-weight: 400;\">Martha Henriques, Editor at BBC Future Planet</span>\r\n\r\n<span style=\"font-weight: 400;\">Twitter:</span> <a href=\"https://twitter.com/martha_rosamund?\"><span style=\"font-weight: 400;\">@Martha_Rosamund</span></a>[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"BBC Future Planet: sustainable development in a solutions newsroom","post_link":"https://media-innovation.news/media-lab/bbc-future-planet/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"A screenshot of the BBC Future Planet website front page, including a story about Lagos in Nigeria, which is often flooded\" width=\"300\" height=\"136\" src=\"https://media-innovation.news/wp-content/uploads/2021/01/Screen-Shot-2021-02-16-at-14.51.31-300x136.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Green media, Innovation Case","post_tags":"BBC Future Planet, Carbon emissions, Digital footprint, Diversity, Flying, Martha Henriques, Solutions journalism","%_edit_lock%":"1637676857:933","%_edit_last%":"933","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Broadcasting House, Portland Pl, Marylebone, London W1A 1AA, UK","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"England","%_wpgmp_location_country%":"United Kingdom","%_wpgmp_metabox_latitude%":"51.5188884","%_wpgmp_metabox_longitude%":"-0.1439307","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_thumbnail_id%":"15525","%_yoast_wpseo_primary_category%":"69","%_yoast_wpseo_focuskw%":"BBC future planet","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_title%":"BBC Future Planet: sustainable development in a solutions newsroom","%_yoast_wpseo_metadesc%":"BBC Future Planet is calculating its digital footprint and cutting flying, which has cut costs and increased diversity in the newsroom.","%_yoast_wpseo_opengraph-title%":"BBC Future Planet: sustainable development in a solutions newsroom","%_yoast_wpseo_opengraph-description%":"BBC Future Planet is calculating its digital footprint and cutting flying, which has cut costs and increased diversity in the newsroom.","%_yoast_wpseo_opengraph-image%":"https://media-innovation.news/wp-content/uploads/2021/01/Screen-Shot-2021-01-26-at-15.06.22.png","%_yoast_wpseo_opengraph-image-id%":"15494","%_yoast_wpseo_twitter-title%":"BBC Future Planet: sustainable development in a solutions newsroom","%_yoast_wpseo_twitter-description%":"BBC Future Planet is calculating its digital footprint and cutting flying, which has cut costs and increased diversity in the newsroom.","%_yoast_wpseo_twitter-image%":"https://media-innovation.news/wp-content/uploads/2021/01/Screen-Shot-2021-01-26-at-15.06.22.png","%_yoast_wpseo_twitter-image-id%":"15494","taxonomy=category":"Green media, Innovation Case","taxonomy=post_tag":"BBC Future Planet, Carbon emissions, Digital footprint, Diversity, Flying, Martha Henriques, Solutions journalism"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15492,"infowindow_disable":false},{"source":"post","title":"Schibsted: after two centuries of innovation &#8211; people and planet are now the lead story","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Logo of the Second Hand Effect marketplaces work on an image of a forest with hills and the sky in the background\" width=\"300\" height=\"173\" src=\"https://media-innovation.news/wp-content/uploads/2020/12/Screen-Shot-2020-12-08-at-22.17.11-300x173.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Green media</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Schibsted: after two centuries of innovation &#8211; people and planet are now the lead story</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Since a shake-up at the top, Head of Sustainability, Britt Nilsen, is making sure the company is leading on diversity and the environment.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/schibsted-people-planet/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Since a shake-up at the top, Head of Sustainability, Britt Nilsen, is making sure the company is leading on diversity and the environment.","address":"Akersgata 55, 0180 Oslo, Norway","location":{"lat":"59.91535500000001","state":"Oslo","country":"Norway","lng":"10.7432203","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/schibsted-people-planet/","zoom":2,"extra_fields":{"post_excerpt":"Since a shake-up at the top, Head of Sustainability, Britt Nilsen, is making sure the company is leading on diversity and the environment.","post_content":"[vc_row][vc_column width=\"1/4\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1><span style=\"font-weight: 400;\">Schibsted: after two centuries of innovation - people and planet are now the lead story</span></h1>\r\n<span style=\"font-weight: 400;\">As a finance person by background, Britt Nilsen may not be considered your average ecowarrior, or indeed, your typical innovator.</span>\r\n\r\n<span style=\"font-weight: 400;\">But it is precisely her understanding of the numbers that has helped Norwegian media giant </span><a href=\"https://schibsted.com/\"><span style=\"font-weight: 400;\">Schibsted</span></a><span style=\"font-weight: 400;\"> put environmental sustainability at the centre of the organisation.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cYou don't have a separate strategy for sustainability, it needs to be anchored in,\u201d she explains, although no doubt similar organisations haven\u2019t got that far yet.</span>\r\n\r\n<span style=\"font-weight: 400;\">Schibsted has almost 200 years of work under its belt - and after becoming a public limited company in the 1980s, then getting listed on the stock exchange in 1992 - its reputation has grown outside of its native country.</span>\r\n\r\n<span style=\"font-weight: 400;\">A decade into buying new media companies and creating its own, even while the Dotcom Bubble expanded and subsequently burst, in 2007, Harvard Business School professor Bharat Anand </span><a href=\"https://www.nytimes.com/2007/02/18/business/worldbusiness/18iht-papers.4633531.html\"><span style=\"font-weight: 400;\">told the </span><i><span style=\"font-weight: 400;\">New York Times</span></i></a><span style=\"font-weight: 400;\"> this company was \u201csomething quite special\u201d.</span>\r\n\r\n<span style=\"font-weight: 400;\">In 2001, for example, after 160 years delivering newspapers, Schibsted launched its Distribution Innovation company. It has, </span><a href=\"https://schibsted.com/2020/03/23/minimizing-the-environmental-impact/\"><span style=\"font-weight: 400;\">most recently</span></a><span style=\"font-weight: 400;\">, been using AI and machine-learning to learn even more about getting news to your door - not least, how to do it better while protecting the planet.</span>\r\n\r\n<span style=\"font-weight: 400;\">Schibsted\u2019s core news media business now extensively covers both Norway and Sweden - nine news brands along with their associated multimedia offerings - styled as Schibsted Norway and Schibsted Sweden respectively.</span>\r\n\r\n<span style=\"font-weight: 400;\">And the company has been successful, compared to many international counterparts, at converting people into online subscribers.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt looked really dark at one point,\u201d Nilsen admits, \u201cbut that has been a huge success. We have a lot of online subscribers and it's increasing.\u201d She puts some of this down to a relatively strong level of trust in news media in the Nordic countries.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOf course, we're still reliant on the advertising part. But we are trying to turn around the business so that the online newspaper will be a standalone, financially safe business. So that is important.\u201d</span>\r\n<h3>Investments and marketplaces</h3>\r\n<span style=\"font-weight: 400;\">Along with its </span><a href=\"https://schibsted.com/about/who-we-are/next/\"><span style=\"font-weight: 400;\">Next portfolio</span></a><span style=\"font-weight: 400;\"> of investments in everything from consumer finance to dating apps, Schibsted has found greater success with marketplaces than something like the UK\u2019s </span><a href=\"https://www.theguardian.com/media/2014/jan/22/guardianmediagroup-theguardian\"><i><span style=\"font-weight: 400;\">Guardian </span></i><span style=\"font-weight: 400;\">did in its former ownership</span></a><span style=\"font-weight: 400;\"> of used car exchange Autotrader.</span>\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone size-full wp-image-15471\" src=\"https://media-innovation.news/wp-content/uploads/2020/12/Screen-Shot-2020-12-01-at-10.14.23.png\" alt=\"The logos of nine Schibsted Next portfolio companies\" width=\"1214\" height=\"574\" />Its latest big deal has seen marketplace group Adevinta spin out of Schibsted, while </span><a href=\"https://www.adevinta.com/news/adevinta-signs-agreement-to-acquire-ebay-classifieds-group/\"><span style=\"font-weight: 400;\">buying up eBay\u2019s Classifieds business</span></a><span style=\"font-weight: 400;\">, which includes websites like Gumtree, for around $9 billion.</span>\r\n\r\n<span style=\"font-weight: 400;\">When the transaction is finalised early next year, Nilsen says Adevinta will be the \u201cworld's largest marketplace\u201d. But this isn\u2019t simply a story of diversification.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe are trying to have people move into circular consumption instead of being in the linear element. Other things we are thinking about are, is it possible to kind of make a \u2018circularity index\u2019, or a kind of a stamp on new products or used products? Then if you have to buy new things, you should at least buy quality and know \u2018this is the value that you can sell it for after three or four years\u2019, for example.\u00a0</span>\r\n\r\n\u201cOn 12 of our marketplaces in 2019, we have calculated the effect on the environment and also on how many materials we are saving by trading second hand, instead of having to produce a new one and throwing away a used one.\"\r\n\r\n<span style=\"font-weight: 400;\">\u201cIf you want to buy, for example, a sofa and then a message comes up \u2018OK, if you buy this sofa, you will save this much CO2 emission and this equals the production of three sweaters\u2019, for example. And then, on their account, they will accumulate the effect and how much they have saved.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">And yet still, Nilsen explains, until three years ago, sustainability was \u201csomething on the side\u201d. \u201cIt was more like a compliance issue, following laws or regulations and commitments. We are a participant in the U.N. Global Compact and all that stuff.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">That was until the autumn of 2017, when two diversity challenges struck at once.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe had a reorganisation in Schibsted, where at that point we had put into two business areas, media and marketplaces. And when they set their management teams in those two business areas, and also on the group level, it had a really low female ratio.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd it was a really huge uproar, both internally and externally. \u2018How is it possible in 2017 to do such a stupid thing? This is Norway!\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd, at the same time, #MeToo hit. And on this side, of course, we set the agenda with our newspapers.\u201d</span>\r\n<h3>Incentivising diversity</h3>\r\n<span style=\"font-weight: 400;\">In December 2017, Schibsted set goals for gender equality - a ratio of 40:60 either way on the three highest management levels by the end of 2020 - </span><i><span style=\"font-weight: 400;\">that had consequences.\u00a0</span></i>\r\n\r\n<span style=\"font-weight: 400;\">\u201cFor 2018, they set short-term goals and that was like \u2018we should have a new recruitment policy\u2019, \u2018we should have a diversity and inclusion policy\u2019, \u2018we should have unconscious bias training for managers and recruiters\u2019, \u2018we should establish some networks for women\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd also in the busiest business areas, this was more detailed like, \u2018this is how many men and women should be on the long list, the short list and how many should be hired\u2019 and so on. Really detailed.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBut the smart thing was that they put it as part of the top management's incentives.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">The result was that, in one year, across all the management groups in their companies, the percentage of women leaders went from 34 to 39 per cent.</span>\r\n\r\n<span style=\"font-weight: 400;\">Until this point, environmental sustainability issues had been owned by the group\u2019s communications team, meaning it was considered part of Corporate Social Responsibility, \u201cthe speech you have at the party\u201d.</span>\r\n\r\n<span style=\"font-weight: 400;\">But when Nilsen became Schibsted\u2019s Group Compliance Officer, and now ultimately the Head of Sustainability, she got serious.</span>\r\n\r\n<span style=\"font-weight: 400;\">Her first step was to make sure the company\u2019s Sustainability Report 2017 met the Global Reporting Initiative's (GRI) standards on measurement and transparency. Doing this meant Schibsted\u2019s prospect as an investment improved, as the perception of their Environmental, Social and Governance (ESG) risk went down.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI went to the CEO\u2026 and that was when coming from finance was very handy because I speak their language. I know we have to earn money, but we have to do it in another way.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd so I could tell them that \u2018if we don't have sustainability high up on our agenda, the investors will not be interested, potential recruits will not be interested, and you will lose the best people you have\u2019.\u201d</span>\r\n<h3>Seeing opportunities</h3>\r\n<span style=\"font-weight: 400;\">\u201cI could kind of go through and [show that] the risk of not thinking about this is huge. Look at how Facebook is having scandals with Cambridge. It's not all companies that can take that kind of scandal.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBut my main point in those conversations was that, \u2018yes, we have to comply with laws and regulations and all these things. But that goes without saying because that is kind of a \u2018housecleaning\u2019. What we need to do is look at opportunities\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe can actually earn money and at the same time be sustainable, take good care of the environment and society. But we just have to open our eyes.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">A year later, Kristin Skogen Lund, an experienced executive who had in the early 2000s led the Schibsted-owned Aftenposten, joined as the group\u2019s first female CEO.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWhen she presented the </span><a href=\"https://schibsted.com/sustainability/\"><span style=\"font-weight: 400;\">strategy for Schibsted</span></a><span style=\"font-weight: 400;\">, we have a pyramid, and on top we have \u2018purpose\u2019, \u2018make sure it matters\u2019. And I was so happy I could just cry because </span><i><span style=\"font-weight: 400;\">that is sustainability</span></i><span style=\"font-weight: 400;\">. It's all about making sure that sustainability is in the core of our business. It is kind of the \u2018higher sky\u2019 you're looking towards in everything you do.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">So in autumn 2019, Schibsted took a big look at what mattered.</span>\r\n<h3>What matters?</h3>\r\n<span style=\"font-weight: 400;\">\u201cWe did a lot of benchmarking against our peers and others, and we looked at the risks and opportunities. And we did a lot of stakeholder dialogues. We asked a lot of questions, got a lot of answers, and we asked our users, readers, our advertisers, investors and the board. And we had like 3,500 answers to this.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd then we kind of collected that into one result. And then I asked the executive team, \u2018what do you think about this?\u2019. I got 90 minutes with the executive team, which I was very pleased to get, and kind of landed on \u2018OK, these are the aspects of sustainability that is important for Schibsted\u2019.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">For the company\u2019s </span><a href=\"https://static.schibsted.com/wp-content/uploads/2020/04/03155447/Sustainability-Report-2019.pdf\"><span style=\"font-weight: 400;\">Sustainability Report 2019</span></a><span style=\"font-weight: 400;\"> then, the group used both GRI and the Sustainability Accounting Standards Board (SASB) reporting standards to devise a hierarchy of sustainability issues that were collaboratively decided to be material to the business.</span>\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone size-full wp-image-15472\" src=\"https://media-innovation.news/wp-content/uploads/2020/12/Screen-Shot-2020-12-01-at-10.01.09.png\" alt=\"Schibsted's Pyramid of sustainability priorities: at the bottom, hygiene aspects; in the middle, focus aspects; at the top, unique aspects\" width=\"1127\" height=\"497\" />\u201cAnd they are the responsibility of the executive team,\u201d Nilsen explains. \u201cSo I have had meetings with every one of them and set long-term ambitions, short-term targets, action plans, KPIs to measure and so on.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo it's not my goals. It's not my ambitions for sustainability, it is out in the business areas and in the group functions.\u201d</span>\r\n<h3>Tackling the supply chain</h3>\r\n<span style=\"font-weight: 400;\">At the bottom, so-called \u2018hygiene issues\u2019 are things like supply-chain management.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo now we have a supplier code of conduct, which is also reflecting our own </span><a href=\"https://schibsted.com/about-2/\"><span style=\"font-weight: 400;\">Code of Conduct</span></a><span style=\"font-weight: 400;\">,\u201d Nilsen says. \u201cAnd it's, of course, in alignment with human rights\u2026 and all those international standards.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd the thinking is now that, whenever we sign a contract with a new supplier or we renew a contract, this will be part of the agreements. We are mapping the risk for those companies, where are the highest risks, and that could be country-related as well. And which companies should we go for first.</span>\r\n\r\n<span style=\"font-weight: 400;\">The company has software that identifies high-risk areas, flags them with suppliers so they know what needs to change, and they help them change their practices - or they stop using them.</span>\r\n\r\n<span style=\"font-weight: 400;\">One marketplace presenting a sustainability risk is its huge one in used cars. \u201cIt will at some point disappear,\u201d she acknowledges. \u201cSo we\u2019re seeing those business opportunities moving into rental, leasing, sharing, that kinds of business with cars, for example.</span>\r\n\r\n<span style=\"font-weight: 400;\">An area that has been challenging for the entire industry, due to its complexity, is measuring the environmental impact of digital networks, but Schibsted is currently testing a new tool that has just been created by the </span><a href=\"http://www.bristol.ac.uk/news/2020/january/dimpact.html\"><span style=\"font-weight: 400;\">DIMPACT</span></a><span style=\"font-weight: 400;\"> collaboration out of the University of Bristol in the UK.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cHow are you calculating the electricity you are using from when we have made a product and until it's read or streamed or heard or whatever the users are doing? Nobody has been able to do this because it's too complicated, Nilsen adds.</span>\r\n\r\n<span style=\"font-weight: 400;\">A remaining problem for any news media organisation is the reliance of digital media technologies that appear to be inherently bad for the planet. We are lucky in the Nordics though, with our high share of renewable energy.</span>\r\n<h3>Responsible marketing</h3>\r\n<span style=\"font-weight: 400;\">While still reliant on advertising, \u2018responsible marketing\u2019 also makes it onto the company\u2019s sustainability pyramid as an \u2018focus aspect\u2019.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe had Extinction Rebellion rallying outside our offices because we have a very popular podcast in one of our newspapers - and one of the largest oil companies in Norway had three podcasts with that newspaper brand.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe may have advertising for Black Friday, but on the other side, we are trying to make people reduce their consumption and go into more circular consumption. We have advertising for gambling. And on the other side, we are writing about gamble addicts.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo what we want to do is map all those dilemmas and see if we need a policy to regulate what kind of advertising can we actually do.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">She points to the </span><a href=\"https://www.theguardian.com/media/2020/jan/29/guardian-to-ban-advertising-from-fossil-fuel-firms-climate-crisis\"><span style=\"font-weight: 400;\">UK Guardian\u2019s decision to reject fossil fuel advertising</span></a><span style=\"font-weight: 400;\"> in its bid for sustainability - but also acknowledges Norway\u2019s almost synonymous link with fossil fuels.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI want the people involved being able to say, \u2018OK, yes, we do this </span><i><span style=\"font-weight: 400;\">because</span></i><span style=\"font-weight: 400;\">\u2019, \u2018we can have advertising for this </span><i><span style=\"font-weight: 400;\">because</span></i><span style=\"font-weight: 400;\">\u2019. We have to decide, and this is not easy because we have different types of companies and so on, but we need to have a conscious relationship across the group to what we're actually doing. And that is it in itself is something new.\u201d</span>\r\n<h3>Measuring 'brainprint'</h3>\r\n<span style=\"font-weight: 400;\">But, perhaps most interesting, is the company\u2019s consideration of its \u201cbrainprint\u201d.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOn the top, you have what we call \u2018unique aspects\u2019. And this is really our business. This is our journalism. This is our marketplaces and this is our Next companies. And the thing with the pyramid is that the higher up in the pyramid you get, the higher is the positive impact on society and the environment.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe are the kind of company that has much more \u2018brainprint\u2019 than we have footprint. We affect people's minds. We are moving them and we are giving them the power to take better decisions.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWhat we do with our own emissions, is of course important, but we are really good at measuring environmental effects. Our own emissions are quite small compared to what we are able to accomplish by offering marketplaces for second-hand trade.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe have </span><a href=\"https://schibsted.com/secondhandeffect/\"><span style=\"font-weight: 400;\">done that calculation to see how much is that effect on society</span></a><span style=\"font-weight: 400;\"> and for 2019, the calculation shows that for 12 of our marketplaces, we have potentially saved CO2e emission equal to 50 percent of the total emissions in Norway for one year. Huge figures.</span>\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone size-full wp-image-15473\" src=\"https://media-innovation.news/wp-content/uploads/2020/12/Screen-Shot-2020-12-02-at-11.07.37.png\" alt=\"Infographic showing Schibsted's emissions savings from its marketplaces in 2019 - equal to 50% of Norway's entire emissions that year\" width=\"594\" height=\"351\" /></span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe are not good at measuring our effect on society. Like \u2018how do you measure your journalism?\u2019. \u2018How do you measure the content impact?\u2019. So that is a project we're starting now.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">But, of course, here there are considerations about objectivity.\u00a0</span>\r\n\r\n\u201cIt is a discussion. \u2018Should we be just mirrors, or should we be movers to kind of nudge society towards something that we think is for the best?\u2019 And it\u2019s a difficult discussion because the newspapers are supposed to be objective.\r\n\r\n\u201cOf course, this is part of what we are doing, because, especially on our marketplaces, where we facilitate second-hand trade, we are nudging people a lot. \u2018How can you take care of your things?\u2019 We have written books about it\u2026 So we have \u2018here are some tips on how you can take care of your things\u2019.\u201d\r\n<h3>Making changemakers</h3>\r\n<span style=\"font-weight: 400;\">Given that Nilsen has only just made her first team hire, this all sounds like a lot of work, so she\u2019s created a Sustainability Changemaker Programme at Schibsted where 15 people from across the group, genders, business function and country, get to use 10 per cent of their time to work on sustainability.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd then we're looking into like \u2018what are the business opportunities within the circular economy\u2019, \u2018what are new business opportunities within news media?\u2019.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">She does not believe that financial and environmental sustainability are mutually exclusive, \u201cbut you need to grow in a different way and you need to measure differently\u201d.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt's not enough to just look into the financial terms because then you are not pricing the externalities,\u201d she agrees. \u201cYou have to put the prices of everything, of society and environment, into the calculation. And then you can start looking at, \u2018OK, what are the terms of growth, then?\u2019.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Despite all of Schibsted\u2019s success, she says it will take even them a lot of time to become mature in these areas.</span>\r\n\r\n<span style=\"font-weight: 400;\">The company\u2019s diversity work so far, including </span><a href=\"https://schibsted.com/2020/03/24/reaching-diversity-in-the-news/\"><span style=\"font-weight: 400;\">using AI to understand</span></a><span style=\"font-weight: 400;\"> whether using images that are more representative of readers can increase subscriptions (it can!), has been quite limited to gender.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Nilsen does put a large amount of this progress down to Kristin Skogen Lund\u2019s leadership, but inspiring leaders aren\u2019t quite enough.</span>\r\n\r\nNext, Nilsen says, \u201cit\u2019s about how can you give your leaders, your managers the right tool in order to unlock the potential that we have in a diverse workforce, to create innovation, to create value?\u201d.\r\n\r\n<span style=\"font-weight: 400;\">\u201cBecause this is all about mind shifting and you have to start thinking differently. You can't look at it as a compliance, that you just \u2018do no harm\u2019 and give some money to charity and you're off the hook. This is all about taking it into your core.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI love the expression, I heard it the other day, that \u2018diversity is having a seat at the table and inclusion is having a voice and belonging is being heard\u2019, so if you can get into that type of culture and make sure that people are heard, then you will have the right thinking.\u201d</span>\r\n\r\nCONTACT\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone size-full wp-image-15474\" src=\"https://media-innovation.news/wp-content/uploads/2020/12/Britt-Nilsen-.jpeg\" alt=\"Britt Nilsen\" width=\"120\" height=\"120\" /></span>\r\n\r\n<span style=\"font-weight: 400;\">Britt Nilsen, Head of Sustainability at Schibsted</span>\r\n\r\n<span style=\"font-weight: 400;\">Twitter: <a href=\"https://twitter.com/nilsenbritt\">@NilsenBritt</a> <a href=\"https://twitter.com/SchibstedGroup\">@SchibstedGroup</a></span>[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"Schibsted: after two centuries of innovation &#8211; people and planet are now the lead story","post_link":"https://media-innovation.news/media-lab/schibsted-people-planet/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Logo of the Second Hand Effect marketplaces work on an image of a forest with hills and the sky in the background\" width=\"300\" height=\"173\" src=\"https://media-innovation.news/wp-content/uploads/2020/12/Screen-Shot-2020-12-08-at-22.17.11-300x173.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Green media","post_tags":"Adevinta, Britt Nilsen, Norway, Schibsted, Sweden","%_edit_lock%":"1637839492:933","%_edit_last%":"933","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Akersgata 55, 0180 Oslo, Norway","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Oslo","%_wpgmp_location_country%":"Norway","%_wpgmp_metabox_latitude%":"59.91535500000001","%_wpgmp_metabox_longitude%":"10.7432203","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"15476","%_yoast_wpseo_focuskw%":"Schibsted","%_yoast_wpseo_title%":"Schibsted: after two centuries of innovation - people and planet are next","%_yoast_wpseo_metadesc%":"Since a shake-up at the top, Head of Sustainability, Britt Nilsen, is making sure the company is leading on diversity and the environment.","%_yoast_wpseo_linkdex%":"68","%_yoast_wpseo_primary_category%":"347","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"","taxonomy=category":"Green media","taxonomy=post_tag":"Adevinta, Britt Nilsen, Norway, Schibsted, Sweden"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15465,"infowindow_disable":false},{"source":"post","title":"Lenfest Institute: working with the Philly Inquirer as a &#8216;test kitchen&#8217; for COVID innovation and more","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"This is an image of a line of cars queued up for people trying to get a coronavirus test in Philadelphia taken by Tim Tai of the Philadelphia Inquirer\" width=\"300\" height=\"202\" src=\"https://media-innovation.news/wp-content/uploads/2020/10/Coronavirus-Testing-Tim-Tai-Philadelphia-Inquirer-300x202.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lenfest Institute: working with the Philly Inquirer as a &#8216;test kitchen&#8217; for COVID innovation and more</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The Lenfest Institute was created through a philanthropic donation from media tycoon Gerry Lenfest, gifted alongside his ownership of the Philadelphia Inquirer. Editorial and digital strategy manager Joseph Lichterman explains what that has meant.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/lenfest-institute-philly-inquirer/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The Lenfest Institute was created through a philanthropic donation from media tycoon Gerry Lenfest, gifted alongside his ownership of the Philadelphia Inquirer. Editorial and digital strategy manager Joseph Lichterman explains what that has meant.","address":"801 Market St, Philadelphia, PA 19107, USA","location":{"lat":"39.9514459","city":"Philadelphia","state":"Pennsylvania","country":"United States","lng":"-75.15407739999999","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/lenfest-institute-philly-inquirer/","zoom":2,"extra_fields":{"post_excerpt":"The Lenfest Institute was created through a philanthropic donation from media tycoon Gerry Lenfest, gifted alongside his ownership of the Philadelphia Inquirer. Editorial and digital strategy manager Joseph Lichterman explains what that has meant.","post_content":"[vc_row][vc_column width=\"1/4\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1>Lenfest Institute: working with the Philly Inquirer as a \u2018test kitchen\u2019 for COVID innovation and more</h1>\r\n<i><span style=\"font-weight: 400;\">(Lead image credit: Tim Tai, Philadelphia Inquirer)</span></i>\r\n\r\n<span style=\"font-weight: 400;\">The US\u2019</span><a href=\"https://www.lenfestinstitute.org/\"> <span style=\"font-weight: 400;\">Lenfest Institute</span></a><span style=\"font-weight: 400;\"> only opened its doors in 2016 - and yet the name of its benefactor, Gerry Lenfest - no doubt echoes in his local Pennsylvania and beyond. A </span><a href=\"https://en.wikipedia.org/wiki/Gerry_Lenfest\"><span style=\"font-weight: 400;\">Wikipedia page</span></a><span style=\"font-weight: 400;\"> about him (of course, it\u2019s not a \u2018paper of record\u2019) skips quickly from some of his big achievements to the later years of his life, after he\u2019d made and started to give away his fortune.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">But the early years of this media tycoon\u2019s life are</span><a href=\"https://www.philanthropyroundtable.org/almanac/people/hall-of-fame/detail/gerry-lenfest\"> <span style=\"font-weight: 400;\">perhaps worth remarking on even more</span></a><span style=\"font-weight: 400;\"> - he experienced tragedy and then hardship, and then he took to sea. And it was only after he retrained as a lawyer that he had a chance meeting with another media tycoon, Walter Annerberg, that led to him taking a bet on cable - which paid off.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">And the rest would be history, but it lives on in the</span><a href=\"https://www.philanthropyroundtable.org/almanac/people/hall-of-fame/detail/gerry-lenfest\"> <span style=\"font-weight: 400;\">huge variety of philanthropic work he did</span></a><span style=\"font-weight: 400;\">, not least, leaving more than $20 million to what is now the</span><a href=\"https://www.lenfestinstitute.org/\"> <span style=\"font-weight: 400;\">Lenfest Institute for Journalism</span></a><span style=\"font-weight: 400;\">, gifted alongside the ownership of what remains the </span><i><span style=\"font-weight: 400;\">for-profit Philadelphia Inquirer.</span></i>\r\n\r\n<span style=\"font-weight: 400;\">The</span><i><span style=\"font-weight: 400;\"> Inquirer</span></i><span style=\"font-weight: 400;\"> still prints seven days a week, and adds grants from the Lenfest Institute to its digital subscription offer and a newer donation \u2018ask\u2019, which all make it look like a well-rounded local paper fighting fit for its future.</span>\r\n<h3><span style=\"font-weight: 400;\">Unique business structure</span></h3>\r\n<span style=\"font-weight: 400;\">What may be unique about the Lenfest Institute's relationship with the </span><i><span style=\"font-weight: 400;\">Inquirer</span></i><span style=\"font-weight: 400;\"> is its business structure - a not-for-profit supporting a for-profit - versus those newsrooms that are now exclusively not-for-profit, or those publishers that are owned by a foundation, and are themselves not-for-profit.</span>\r\n\r\n<span style=\"font-weight: 400;\">Joseph Lichterman, the Lenfest Institute's manager of editorial and digital strategy, knows his way around such journalism innovation. He currently produces a newsletter on the topic for the organisation,</span><a href=\"https://www.lenfestinstitute.org/solution-set/\"> <span style=\"font-weight: 400;\">Solution Set</span></a><span style=\"font-weight: 400;\">, and previously worked at the Nieman Journalism Lab at Harvard University.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe've talked in the past about the</span><i><span style=\"font-weight: 400;\"> Inquirer </span></i><span style=\"font-weight: 400;\">as a \u2018test kitchen\u2019, a place to test new ideas and develop new models for local news,\" Lichterman explains. \"And then we can hopefully export them and share lessons with other local news organisations. So I think that's definitely an asset of Lenfest and what makes it unique.\"</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd so, for example, as COVID really took off they took down the paywall for much of the COVID coverage and created a landing page and the top of the landing page had both \u2018subscribe\u2019 and \u2018donate\u2019 links, so folks could support the </span><i><span style=\"font-weight: 400;\">Inquirer</span></i><span style=\"font-weight: 400;\"> in a way that made sense for them.</span>\r\n\r\n<span style=\"font-weight: 400;\">In what is clearly Lenfest-style, these COVID innovations are</span><a href=\"https://www.lenfestinstitute.org/solution-set/all-facts-no-panic-how-the-philadelphia-inquirer-is-covering-coronavirus/\"> <span style=\"font-weight: 400;\">all captured here in full</span></a><span style=\"font-weight: 400;\"> for others to learn from - along with a donation drive, they launched a newsletter, did a roundtable for local people, and one reporter had a stroke of genius when attempting socially distanced news-gathering.</span>\r\n\r\n[caption id=\"attachment_15436\" align=\"alignnone\" width=\"549\"]<img class=\"size-full wp-image-15436\" src=\"https://media-innovation.news/wp-content/uploads/2020/10/Screen-Shot-2020-10-19-at-10.11.58.png\" alt=\"This is a screen grab of a tweet by @mollyeichel, Team Now editor @PhillyInquirer, praising one of her reporters for hitting the streets with a huge handwritten sign asking for people's contributions\" width=\"549\" height=\"592\" /> Socially distanced news-gathering[/caption]\r\n\r\n<span style=\"font-weight: 400;\">\u201cBut, we're still a relatively young organisation and it's a unique relationship because we're the non-controlling owners,\" he adds. \"They have a separate business staff, separate leadership, answer to their own board. The newsroom is totally independent. And so it's about figuring out the best ways to collaborate that works for everyone. And so it's still very much a work in progress.\"</span>\r\n<h3><b>Local Lab</b></h3>\r\n<span style=\"font-weight: 400;\">What adds to its distinctiveness is the</span><a href=\"https://www.lenfestinstitute.org/lenfest-local-lab/\"> <span style=\"font-weight: 400;\">Lenfest Local Lab</span></a><span style=\"font-weight: 400;\">, which directly supports innovation at the newspaper, led by Sarah Schmalbach, but also sends its work out into the world so others can benefit from what they have learned.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThey\u2019re a sort of a small product UX research team and the idea is to try and think about and identify ways to engage with local audiences in new and innovative ways,\u201d Lichterman explains.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI think one of the things local news organisations struggle with is they get so caught up in the day-to-day coverage, in the day-to-day product development cycle, that it's difficult to take a step back and think about trying new things, running experiments, doing things for the sake of learning and knowledge and advancing the field.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo the Lenfest Local Lab\u2019s goal is to be able to do that type of research and do that type of innovation away from the day-to-day constraints of running the news organisation.\u201d\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">The Lab team is able to work closely with the </span><i><span style=\"font-weight: 400;\">Philly Inquirer</span></i><span style=\"font-weight: 400;\">, with access to their newsroom and journalists. Lichterman says this means they\u2019re often \u201ctrying to present the journalism in different ways and potentially make it more accessible or utilise different functionalities\u201d.</span>\r\n\r\n<span style=\"font-weight: 400;\">Their latest experiment on doing local news at scale is the first of a number of hyperlocal newsletters, which is</span><a href=\"https://www.lenfestinstitute.org/lenfest-local-lab/the-lenfest-local-lab-and-the-philadelphia-inquirer-launch-the-hook-a-hyperlocal-email-newsletter-serving-fishtown/\"> <span style=\"font-weight: 400;\">launching</span></a> <span style=\"font-weight: 400;\">to cover a neighbourhood in Philadelphia called Fishtown, supported by the</span><a href=\"https://www.lenfestinstitute.org/news-technology-innovation/lenfest-local-lab-the-philadelphia-inquirer-receive-google-gni-innovation-challenge-support-to-build-automated-neighborhood-newsletters/\"><span style=\"font-weight: 400;\"> Google News Initiative</span></a><span style=\"font-weight: 400;\">.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThey\u2019re trying to see if there are ways to cover neighbourhoods in more automated ways,\u201d Lichterman explains. \u201cAs \u2018metro newsrooms\u2019 have shrunk, they've had to sort of \u2018regionalise\u2019 their coverage and are not able to provide as targeted, on-the-ground reporting.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd so the idea with </span><i><span style=\"font-weight: 400;\">The Hook</span></i><span style=\"font-weight: 400;\"> is to be able to combine original reporting with the </span><i><span style=\"font-weight: 400;\">Inquirer\u2019s</span></i><span style=\"font-weight: 400;\"> existing reporting, and public data sources, and compile it in a way that is valuable and interesting and user-friendly, and also potentially sustainable. So they're also working with the </span><i><span style=\"font-weight: 400;\">Inquirer </span></i><span style=\"font-weight: 400;\">to sell ads in the newsletter, because if most of the readers are going to be in the neighbourhoods, if you\u2019re a local business, that's a good audience you want to reach.\u201d\u00a0</span>\r\n<h3><b>Collaborative, experimental, open</b></h3>\r\n<span style=\"font-weight: 400;\">The UX lead on the project, Faye Teng, provides a</span><a href=\"https://www.lenfestinstitute.org/lenfest-local-lab/part-1-explore-a-step-by-step-guide-to-using-ux-research-for-local-news-product-development/\"> <span style=\"font-weight: 400;\">really thorough and refreshingly transparent account</span></a><span style=\"font-weight: 400;\"> of what you might want to do before trying the same thing.</span>\r\n\r\n<span style=\"font-weight: 400;\">Much of what the Lenfest Institute does is collaborative, much is experimental and much is open. The Lab</span><a href=\"https://www.lenfestinstitute.org/lenfest-local-lab/the-lenfest-lab-and-the-brown-institute-are-partnering-on-a-project-to-map-local-news/\"> <span style=\"font-weight: 400;\">also worked with</span></a><span style=\"font-weight: 400;\"> the</span><a href=\"https://brown.columbia.edu/\"> <span style=\"font-weight: 400;\">Brown Institute for Media Innovation</span></a><span style=\"font-weight: 400;\"> to use artificial intelligence to map out the kinds of places that get covered in the news Philadelphia - and the kinds of stories that get written.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">When they set out, they asked:</span>\r\n\r\n[caption id=\"attachment_15435\" align=\"alignnone\" width=\"792\"]<img class=\" wp-image-15435\" src=\"https://media-innovation.news/wp-content/uploads/2020/10/Screen-Shot-2020-10-16-at-16.54.11.png\" alt=\"This is a screen grab of a list of questions from the Brown collaboration. It reads: How does local news coverage lay out across a region? If there are gaps, how can they be filled? Should they be? Does the sentiment, length, or frequency of local news coverage vary by geography? If so, what might the underlying reasons be? Are there tools that can be built to solve any issues that the map may uncover? Are there ways to provide automatic local angles to national stories? What types of geography exist in news? Points, lines, polygons? How are stories with various locations evaluated and presented on the map? Can we predict where news is happening but it isn\u2019t getting covered? Does the quantity of local news reporting scale in proportion to the population of an area? If not, why? What trends within news coverage can only be explained by pairing time and geography?\" width=\"792\" height=\"395\" /> What can be learned from seeing a set of article locations on a map?[/caption]\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd they've been able to use the underlying technology to create a COVID landing page,\u201d Lichterman explains, \u201cso if you want localised COVID coverage about your county, for example, you can go there and it\u2019ll pull in automatically all the COVID stories that are written. So that means more localised coverage of schools or restaurant openings and things like that.\u201d\u00a0</span>\r\n<h3><b>Diversity, equity, inclusion</b></h3>\r\n<span style=\"font-weight: 400;\">In a similar vein, the Lab has mapped restaurant reviews and public art, and also committed to make sure this is a tool that can be used in any newsroom.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBut it\u2019s also thinking about diversity, equity and inclusion issues, in making sure that coverage is representative of communities,\u201d Lichterman adds. \u201cI do think journalists need to do a better job of amplifying voices and making sure that we're representative of communities. It\u2019s the right moral thing to do, but journalists sort of have this sense of duty to the public and we need to make sure we're actually serving the public.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd there's a real business imperative, also, in that if you are going to become more dependent on reader revenues, for example, whether it's through subscriptions or donations or membership, whatever it may be, people are going to want to see themselves in the coverage if they're going to contribute to it and support the journalism. So I think that's something worth keeping in mind as well.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Lichterman is keen to talk \u2018membership, donation, subscription, or not?\u2019, as </span><a href=\"https://www.lenfestinstitute.org/news-technology-innovation/the-lenfest-institute-is-partnering-with-the-membership-puzzle-project-to-create-a-guide-to-membership-models-in-news/\"><span style=\"font-weight: 400;\">earlier this year</span></a><span style=\"font-weight: 400;\"> the Lenfest Institute partnered with</span><a href=\"https://membershippuzzle.org/\"><span style=\"font-weight: 400;\">Membership Puzzle Project</span></a><span style=\"font-weight: 400;\"> (MPP) to create the Google News Initiative-backed Membership Guide, MPP's latest effort to try to help answer the industry\u2019s questions on this increasingly dynamic revenue stream.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">The team, headed by Jay Rosen of New York University, with the research directed by Elizabeth Hansen from the Tow Center for Digital Journalism at Columbia, and managed by Ariel Zirulnick, who\u2019s also head of MPP\u2019s</span><a href=\"http://www.membershippuzzle.org/fund\"><span style=\"font-weight: 400;\"> Membership in News Fund</span></a><span style=\"font-weight: 400;\">,</span><a href=\"https://www.lenfestinstitute.org/news-technology-innovation/the-lenfest-institute-is-partnering-with-the-membership-puzzle-project-to-create-a-guide-to-membership-models-in-news/\"> <span style=\"font-weight: 400;\">set out to ask</span></a><span style=\"font-weight: 400;\">, and where possible, answer:</span>\r\n\r\n[caption id=\"attachment_15434\" align=\"alignnone\" width=\"841\"]<img class=\"size-full wp-image-15434\" src=\"https://media-innovation.news/wp-content/uploads/2020/10/Screen-Shot-2020-10-16-at-16.04.41.png\" alt=\"This is a screen grab of a set of questions from the Membership Puzzle research project, which reads: What is the value proposition for creating a membership program What motivates people to become members? What costs should news organizations plan for, and what revenue can they expect? What tools and technology do news organizations need to run a membership program? How does a news organization launch and grow a membership program? What does it take to develop a member-focused culture in the newsroom? How does a news organization retain members and measure the success of its membership program? What does membership mean for news organizations that serve communities underserved by mainstream media institutions?\" width=\"841\" height=\"376\" /> What do we need to know before we do membership programmes?[/caption]\r\n\r\n<span style=\"font-weight: 400;\">The result is the hugely comprehensive</span><a href=\"https://membershipguide.org/\"> <span style=\"font-weight: 400;\">Membership Guide</span></a><span style=\"font-weight: 400;\">,</span><a href=\"https://www.lenfestinstitute.org/news-technology-innovation/membership-guide-launch-membership-puzzle/\"> <span style=\"font-weight: 400;\">launched in September 2020</span></a><span style=\"font-weight: 400;\">, providing what Lichterman says the team considers \u201ca tactical, practical guide for implementing membership programmes\u201d.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">After more than three years of \u2018public research\u2019 by the Membership Puzzle Project itself, the Guide brings together more than 30 case studies and interviews with 50 newsrooms.\u00a0</span>\r\n<h3><b>Membership, donation, subscription</b></h3>\r\n<span style=\"font-weight: 400;\">Lichterman explains that the project \u201clooks at every step of your membership journey, from deciding if membership is right for you - </span><i><span style=\"font-weight: 400;\">because it isn't necessarily for every organisation</span></i><span style=\"font-weight: 400;\"> - to then launching and implementing a membership programme, and continuing to iterate and grow on it\u201d.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Explaining some key takeaways from the Guide, he says: \u201cmembership is different from subscription, </span><i><span style=\"font-weight: 400;\">necessarily</span></i><span style=\"font-weight: 400;\">. If you're a subscriber, you pay to get access. So there is a paywall and it's really more transactional.</span>\r\n\r\n<span style=\"font-weight: 400;\">\"With membership, you're feeling like you're joining a movement, you're part of a cause. You're giving not only your money, but potentially time and ideas, and other sort of things. You access it because it's something to believe in and something that you think is beneficial to your community, or society more broadly.\u201d\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">But he acknowledged there\u2019s lots to be learned from older subscription models, and that there is much to be said for \u2018doing a number of things to make money\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201c</span><i><span style=\"font-weight: 400;\">The Guardian</span></i><span style=\"font-weight: 400;\"> is a really good example, you can sort of put multiple models together, so subscription and membership aren't mutually exclusive. And you can incorporate \u2018memberful routines\u2019 and start to build toward developing that loyal audience and making people open to the idea of membership, and being engaged with the coverage before launching a specific membership programme. So you're able to sort of do it in stages and meet your audience where they are.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">One publisher interviewed for the project, Lichterman explains, when considering whether people would be willing and able to pay online to join, realised they had a large part of their audience who wouldn\u2019t or couldn\u2019t. \u201cThey had to rethink their strategy to set it up for mailing and things like that\u2026 They have cheques, which is something you might need to think about. But, then, once you know you have an audience who's going to pay online, you can set up recurring payments and optimise your checkout flow and do all these e-commerce strategies to really be able to do that well.\u201d</span>\r\n<h3><b>Digital marketers with a good tech stack</b></h3>\r\n<span style=\"font-weight: 400;\">He emphasised the need to \u2018think like digital marketers\u2019 and that, where a lot of newsrooms, legacy or led by a team of journalists in a startup, can fail to appreciate a good tech stack.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThey may think that it's just part of a website and publish, but not only do you need a website, you need a CRM to be able to track your members and the way they're interacting with you, and to be able to handle payments. You need an email service provider. You need to have APIs connecting all of those. And, if you're going to do events, you need a platform being able to do events on and things like that. And so it gets more complicated and you want all those things to be able to talk together.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">He emphasised membership isn\u2019t a silver bullet and pointed to very successful organisations like ProPublica, which actively seeks donations but does not have a membership program, instead it seeks reader input on particular investigations. Likewise, the </span><i><span style=\"font-weight: 400;\">New York Times</span></i><span style=\"font-weight: 400;\"> is the</span><i><span style=\"font-weight: 400;\"> New York Times,</span></i><span style=\"font-weight: 400;\"> and its subscription model works just fine.</span>\r\n\r\n<span style=\"font-weight: 400;\">Something like</span><a href=\"https://blackballad.co.uk/\"> <i><span style=\"font-weight: 400;\">Black Ballad</span></i></a><span style=\"font-weight: 400;\">, also in the Guide, launched a Slack community for Black women. \u201cTo do that intentionally is a great service to them and a great example of why representative media is so essential, you're able to have conversations that you wouldn't be able to have otherwise. And then, because </span><i><span style=\"font-weight: 400;\">Black Ballad</span></i><span style=\"font-weight: 400;\"> has such a foothold in that community and is able to really identify that and be representative, then there's a business opportunity there as well, whether it's marketing or advertising or membership, which they've invested in.\"</span>\r\n\r\n<span style=\"font-weight: 400;\">MPP, Lenfest, and Texas Tribune\u2019s RevLab are also offering a free,</span><a href=\"https://www.lenfestinstitute.org/lenfest-news-philanthropy-network/membership-101/\"> <span style=\"font-weight: 400;\">Membership 101</span></a><span style=\"font-weight: 400;\"> training course for newsrooms through its</span><a href=\"https://www.lenfestinstitute.org/lenfest-news-philanthropy-network/\"> <span style=\"font-weight: 400;\">Lenfest News Philanthropy Network</span></a>, which feels like another opportunity to extend the legacy of this work.\r\n<h3><b>Community listening</b></h3>\r\n<span style=\"font-weight: 400;\">Through the Knight-Lenfest Local News Transformation Fund, a joint initiative with the Knight Foundation, it has also recently invested in the</span><a href=\"https://www.lenfestinstitute.org/covid19fund/\"> <span style=\"font-weight: 400;\">Philadelphia COVID-19 Community Information Fund</span></a><span style=\"font-weight: 400;\"> supporting almost 20 news organisations to help get information to those that need it locally, and a</span><a href=\"https://www.lenfestinstitute.org/community-listening-engagement-fund/\"> <span style=\"font-weight: 400;\">Community Listening and Engagement Fund</span></a><span style=\"font-weight: 400;\">, around understanding real information needs.</span>\r\n\r\n<span style=\"font-weight: 400;\">The Lenfest Institute's own website is unsurprisingly full of accessible</span><a href=\"https://www.lenfestinstitute.org/coronavirus/\"> <span style=\"font-weight: 400;\">tools and guides about doing journalism in times of COVID</span></a><span style=\"font-weight: 400;\">, from day-to-day reporting, to self-care for journalists.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOne of the good things that's come out of the conversations recently around COVID, is thinking about what actual information communities need to meet their needs,\" Lichterman acknowledges. \"I'm in, for example, a very fortunate place that I have a job where I can work from home... So the information I need for my day-to-day life is probably very different from someone who is a frontline worker and still having to go into work every day at the supermarket or driving a bus.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">And the next thing that\u2019s high up on the list at the Lenfest Institute is developing a standard learning and impact framework for the work they do. \u201cPutting in hypotheses and making sure the data collection is there and seeing how the actual results align with the hypotheses,\u201d Lichterman explains.</span>\r\n\r\n<span style=\"font-weight: 400;\">This feels like the final piece of the puzzle, to ensure a local legacy for Gerry Lenfest, by making sure his money is working to ensure the future of local news, in Philadelphia and beyond.</span>\r\n\r\n<span style=\"font-weight: 400;\">CONTACT</span>\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone size-full wp-image-15448\" src=\"https://media-innovation.news/wp-content/uploads/2020/10/Joseph-Lichterman.jpg\" alt=\"This is an image of Joseph Lichterman, who is interviewed in this article and works at the Lenfest Institute\" width=\"300\" height=\"300\" /></span>\r\n\r\n<span style=\"font-weight: 400;\">Joseph Lichterman, the Lenfest Institute's manager of editorial and digital strategy</span>\r\n\r\n<span style=\"font-weight: 400;\">Twitter:</span><a href=\"https://twitter.com/ylichterman\"> <span style=\"font-weight: 400;\">@ylichterman</span></a><a href=\"https://twitter.com/lenfestinst\"> <span style=\"font-weight: 400;\">@lenfestinst</span></a>[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"Lenfest Institute: working with the Philly Inquirer as a &#8216;test kitchen&#8217; for COVID innovation and more","post_link":"https://media-innovation.news/media-lab/lenfest-institute-philly-inquirer/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"This is an image of a line of cars queued up for people trying to get a coronavirus test in Philadelphia taken by Tim Tai of the Philadelphia Inquirer\" width=\"300\" height=\"202\" src=\"https://media-innovation.news/wp-content/uploads/2020/10/Coronavirus-Testing-Tim-Tai-Philadelphia-Inquirer-300x202.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"COVID, Lenfest Institute, Lenfest Local Lab, local journalism, Philadelphia, Philadelphia Inquirer","%_edit_lock%":"1612209517:1","%_edit_last%":"933","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"801 Market St, Philadelphia, PA 19107, USA","%_wpgmp_location_city%":"Philadelphia","%_wpgmp_location_state%":"Pennsylvania","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"39.9514459","%_wpgmp_metabox_longitude%":"-75.15407739999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"15444","%_yoast_wpseo_primary_category%":"142","%_yoast_wpseo_focuskw%":"Lenfest Institute","%_yoast_wpseo_metadesc%":"Through its unique relationship with the local newspaper, the Lenfest Institute is able to test and share real-life journalism innovation with the industry.","%_yoast_wpseo_linkdex%":"67","%_wp_old_slug%":"lenfest-institute-working-with-the-philly-inquirer-as-a-tech-kitchen-for-covid-innovation-and-more","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Media labs","taxonomy=post_tag":"COVID, Lenfest Institute, Lenfest Local Lab, local journalism, Philadelphia, Philadelphia Inquirer"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15433,"infowindow_disable":false},{"source":"post","title":"The Media Archaeology Lab: letting people discover different possibilities for innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Media Archaeology Lab: letting people discover different possibilities for innovation\" width=\"300\" height=\"167\" src=\"https://media-innovation.news/wp-content/uploads/2020/06/Media-Archaeology-Lab-300x167.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs, Research projects</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">The Media Archaeology Lab: letting people discover different possibilities for innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Since 2009, the Media Archaeology Lab in at the University of Colorado, Boulder, has been welcoming students and the public to get their hands on the not-latest media technologies to help them ask different questions about innovation.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/the-media-archaeology-lab-letting-people-discover-different-possibilities-for-innovation/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Since 2009, the Media Archaeology Lab in at the University of Colorado, Boulder, has been welcoming students and the public to get their hands on the not-latest media technologies to help them ask different questions about innovation.","address":"1320 Grandview Ave, Boulder, CO 80302, USA","location":{"lat":"40.0113303","city":"Boulder","state":"Colorado","country":"United States","lng":"-105.2754692","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/the-media-archaeology-lab-letting-people-discover-different-possibilities-for-innovation/","zoom":2,"extra_fields":{"post_excerpt":"Since 2009, the Media Archaeology Lab in at the University of Colorado, Boulder, has been welcoming students and the public to get their hands on the not-latest media technologies to help them ask different questions about innovation.","post_content":"[vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1><span style=\"font-weight: 400;\">The Media Archaeology Lab: letting people discover different possibilities for innovation</span></h1>\r\n<span style=\"font-weight: 400;\">The </span><a href=\"https://mediaarchaeologylab.com/\"><span style=\"font-weight: 400;\">Media Archaeology Lab</span></a><span style=\"font-weight: 400;\"> (MAL) is a community-driven, public research space in the basement of an unassuming house on the University of Colorado\u2019s Boulder campus.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Along with its name, and its contents, this decade-old project makes for such a local curiosity it was recently named as a lesser-known place for travellers to discover on </span><a href=\"https://www.atlasobscura.com/places/media-archaeology-lab\"><span style=\"font-weight: 400;\">Atlas Obscura</span></a><span style=\"font-weight: 400;\">.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Opened in 2009, it\u2019s now home to a catalogue of more than 1,000 \u201c</span><i><span style=\"font-weight: 400;\">so-called</span></i><span style=\"font-weight: 400;\"> obsolete\u201d media technologies, its founder, Lori Emerson explains.\u00a0</span>\r\n<div class=\"mceTemp\"></div>\r\n\r\n[caption id=\"attachment_15411\" align=\"alignnone\" width=\"300\"]<img class=\"size-medium wp-image-15411\" src=\"https://media-innovation.news/wp-content/uploads/2020/06/Screen-Shot-2020-06-03-at-09.30.38-300x226.png\" alt=\"\" width=\"300\" height=\"226\" /> MAL: the original Nintendo Entertainment System[/caption]\r\n\r\n<span style=\"font-weight: 400;\">Everything from \u2018magic lanterns\u2019 that represent some of the earliest attempts at creating virtual realities, to some of the first desktop computers and games consoles, along with all manner of software and media recordings.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cEverything in the Lab works and is meant to be played with, turned on, researched and even used to create art,\u201d Emerson says.</span>\r\n\r\n<span style=\"font-weight: 400;\">As associate professor in the </span><a href=\"http://english.colorado.edu/\"><span style=\"font-weight: 400;\">English</span></a><span style=\"font-weight: 400;\"> department, along with the near-unique Intermedia Arts, Writing and Performance programme, during term-time Emerson uses the Lab to get more than 200 students every week thinking about \u2018the possible\u2019.\u00a0</span>\r\n<h3>Asking how and why</h3>\r\n<span style=\"font-weight: 400;\">Whether that\u2019s </span><a href=\"https://literaryinfrastructures.wordpress.com/\"><span style=\"font-weight: 400;\">analysing</span></a><span style=\"font-weight: 400;\"> the \u2018how\u2019 of literary production in her English classes - looking at the hardware and the software that got the words onto the page - or \u201cpursuing dead ends in technological development\u201d. But the Lab is open to all.</span>\r\n\r\n<span style=\"font-weight: 400;\">It often gets donations, whether that\u2019s a </span><a href=\"https://twitter.com/mediarchaeology/status/985632489417797632\"><span style=\"font-weight: 400;\">telephone switchboard used by the Stasi</span></a><span style=\"font-weight: 400;\">, the original Japanese version of the Nintendo Entertainment System, </span><a href=\"https://twitter.com/mediarchaeology/status/1055286917623775232\"><span style=\"font-weight: 400;\">the Famicom</span></a><span style=\"font-weight: 400;\">, or a </span><a href=\"https://twitter.com/mediarchaeology/status/1101601244207071234\"><span style=\"font-weight: 400;\">Friden mechanical calculator</span></a><span style=\"font-weight: 400;\">. There\u2019s even an open </span><a href=\"https://mediaarchaeologylab.com/wishlist/\"><span style=\"font-weight: 400;\">wishlist</span></a><span style=\"font-weight: 400;\">, including a callout for desktop and laptop computers from outside North America and the UK.</span>\r\n\r\n[caption id=\"attachment_15416\" align=\"alignnone\" width=\"289\"]<img class=\"size-medium wp-image-15416\" src=\"https://media-innovation.news/wp-content/uploads/2020/06/Screen-Shot-2020-06-03-at-12.07.30-289x300.png\" alt=\"\" width=\"289\" height=\"300\" /> MAL: \"... discovered in a heap of discarded tech of surveillance and bureaucracy shortly after the Berlin wall came down\"[/caption]\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe Lab is really interesting because you can make whatever you want of the collection. At first glance, you might think that it\u2019s only for people interested in the history of computing. </span>\r\n\r\n<span style=\"font-weight: 400;\">\"But, as it turns out, the collection can be used to explore user interfaces, the history of fonts and typefaces, the history of sound recording, early digital art, digital literature, even a bit of film - the list goes on.</span>\r\n<h3>Against \"planned obsolescence\"</h3>\r\n<span style=\"font-weight: 400;\">\u201cThe Lab is really working against this notion of planned obsolescence - in a way, we\u2019re instilling students with a criticality that isn\u2019t available at other places. </span>\r\n\r\n<span style=\"font-weight: 400;\">\"Just trying to get them thinking about the value of a computer from 1976, that works by switches and has no visual output at all, trying to get them to think \u2018well, what could this thing be good for? How can we value this thing?\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe\u2019re trying to instil them with a politics that I hope they take with them to these tech companies or startup companies.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Recent PhD graduate libi striegl used the Lab to design workshops for undergraduate students to get them to think about how to take apart digital devices, put them back together and how to fix them. Another, Maya Livio, has been working closely with Emerson to <a href=\"https://whatisafeministlab.online/\">explore the potential</a> of a \u2018feminist lab\u2019.</span>\r\n\r\n[caption id=\"attachment_15412\" align=\"alignnone\" width=\"300\"]<a href=\"https://loriemersondotnet.files.wordpress.com/2019/11/towards-feminist-labs_critical-makers-reader_maya-livio-and-lori-emerson.pdf\"><img class=\"wp-image-15412 size-medium\" src=\"https://media-innovation.news/wp-content/uploads/2020/06/Screen-Shot-2020-06-03-at-09.40.30-300x172.png\" alt=\"\" width=\"300\" height=\"172\" /></a> Maya Livio and Lori Emerson: Towards feminist labs[/caption]\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe term \u2018feminist lab\u2019 is a handy umbrella term to get people to think harder about all of those little, everyday activities that make up the lab. </span>\r\n\r\n<span style=\"font-weight: 400;\">\"We try to think about \u2018what\u2019s the infrastructure of your lab? How is that infrastructure prohibiting people from either wanting to enter, or physically being able to enter? What\u2019s a feminist budget look like?\u2019.\u00a0</span>\r\n<h3>A transparent and fair lab?</h3>\r\n<i><span style=\"font-weight: 400;\">\u201c\u2018How do you</span></i><span style=\"font-weight: 400;\"> figure out who to accept money from and on what terms? How do you come up with budgets that are transparent, and that are fair, that are based on notions of equity?\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cInfrastructure aside, \u2018how do you run a meeting in a lab that\u2019s inclusive, potentially non-hierarchical, that\u2019s not built on traditional notions of authority? How do you give credit and attribution in terms of the outputs of your lab?\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt sounds like a very small thing but if you were going to publish an article with a group of people, if you actually believe in feminist principles, why would you have the lab director listed first and everyone else listed second, third, fourth? I mean, it\u2019s very administrative, bureaucratic, boring things that have a lot of significance to them, as it turns out.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">As a founder who\u2019s still at the helm, Emerson is rather proud the Lab has lasted.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIn the arts and humanities, labs don\u2019t usually last that long, probably for funding reasons. I think also, at some point, I realised that the Lab was at its best and was only going to survive when it turned into a project that wasn\u2019t about me and my research interests. It turned into a communal enterprise.\u201d</span>\r\n<h3>Powered by volunteers</h3>\r\n<span style=\"font-weight: 400;\">That means an \u201carmy\u201d of 12 volunteers, the </span><i><span style=\"font-weight: 400;\">Mal Pals</span></i><span style=\"font-weight: 400;\">, some from campus, others from technology companies or government, usually with a combination of interest in education and vintage computing, helping with everything from cleaning to cataloguing. It\u2019s usually open for five hours, five or six days a week, to anyone that wants to drop by. \u201cWe really try to keep the Lab an open, porous, welcoming, inclusive space,\u201d she adds.</span>\r\n\r\n<span style=\"font-weight: 400;\">The Lab has hosted artists- and researchers-in-residence since 2013, funding themselves to come for a week or two to spend doing whatever they want - whether that\u2019s </span><a href=\"https://mediaarchaeologylab.com/blog/soft-computers-crochet-patterns-by-sarah-rooney/\"><span style=\"font-weight: 400;\">creating soft crochet patterns out of hard computers</span></a><span style=\"font-weight: 400;\"> to \"inspire computer users to 'look under the hood' of their own machines\", or\u00a0delving into the </span><a href=\"http://mediaarchaeologylab.com/past-artist-in-residence/artist-joel-swanson/\"><span style=\"font-weight: 400;\">meanings created by our keyboards</span></a><span style=\"font-weight: 400;\">.</span>\r\n\r\n[caption id=\"attachment_15407\" align=\"alignnone\" width=\"216\"]<img class=\"size-medium wp-image-15407\" src=\"https://media-innovation.news/wp-content/uploads/2020/06/Screen-Shot-2020-06-03-at-09.18.52-216x300.png\" alt=\"\" width=\"216\" height=\"300\" /> Sarah Rooney: Soft Computers[/caption]\r\n\r\n<span style=\"font-weight: 400;\">Building on her experience with the MAL, Emerson recently teamed up with fellow researchers Darren Wershler and Jussi Parikka to bring together what they all know about the thing we call \u2018media labs\u2019 in </span><a href=\"https://manifold.umn.edu/projects/the-lab-book\"><i><span style=\"font-weight: 400;\">THE LAB BOOK</span></i></a><span style=\"font-weight: 400;\">, out in early 2021.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI was really keen on giving a long history of media labs - so that we aren\u2019t continually living in this present moment, over and over again, where people are like \u2018I\u2019m going to start a lab!\u2019. I think they matter as a subject area - really to try to track how people are appropriating the term - </span><i><span style=\"font-weight: 400;\">sometimes for good and sometimes for ill</span></i><span style=\"font-weight: 400;\">.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAs we found out - a lab can be absolutely anything. We came up with examples of companies calling a line of grooming products \u2018labs\u2019, fashion displays in department stores - \u2018a lab\u2019. I have a colleague who was thinking about getting a group of people together to read - she wanted to call it a \u2018lab\u2019.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">What Emerson and her fellow authors tried to do, detailed on their </span><a href=\"http://whatisamedialab.com/\"><span style=\"font-weight: 400;\">What Is A Media Lab website</span></a><span style=\"font-weight: 400;\">, was understand why people often and continually want to use this word.\u00a0</span>\r\n<h3>Why 'media lab'?</h3>\r\n<span style=\"font-weight: 400;\">\u201cThere\u2019s plenty of examples of \u2018anti-lab\u2019 labs and there are also plenty of examples of labs that appear to be purely appropriating the idea to legitimise what they\u2019re trying to do, by adding a veneer of scientificity.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe have a final chapter called \u2018techniques\u2019 where we were trying to catalogue key techniques that people seem to be using in media labs and giving people the critical apparatus to think about - \u2018why are you obsessed with fabricating or 3D printing? Are you thinking about the larger circumstance about the space that it takes place in?\u2019.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cEn route to providing the longer history, you start to see how there have been some problematic managerial techniques involved in the running of some labs. That maybe people don\u2019t know about or they haven\u2019t thought about.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">And, as it happens, they charted the problem right back to the 19th century lab of Thomas Edison, the now-world-famous brand, </span><a href=\"https://www.menloparkmuseum.org/history\"><span style=\"font-weight: 400;\">Menlo Park</span></a><span style=\"font-weight: 400;\">.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cA lot of these labs have a disconnect between how they market themselves, how they talk about themselves, how they appear, or try to appear, to the public - and what actually goes on. So there\u2019s a lot of talk about \u2018innovation\u2019, \u2018flexibility\u2019, \u2018collaboration\u2019, \u2018interdisciplinarity\u2019 or \u2018</span><i><span style=\"font-weight: 400;\">anti-disciplinarity</span></i><span style=\"font-weight: 400;\">\u2019. </span><span style=\"font-weight: 400;\">\r\n</span><span style=\"font-weight: 400;\">\r\n</span><span style=\"font-weight: 400;\">\u201cSomehow a lot of that rhetoric gets fed into the space itself, and just ends up creating more of the same, and actually creating problematic hierarchies. Or \u2018innovative new technologies\u2019 that lack a politics, or lack understanding of how the technology relates to people and the world.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Reflecting on the COVID-19 pandemic, with the MAL having to get by online, she adds: \u201cIf I had to generalise about labs, I would say, labs are all about hands-on work, so if you can\u2019t do the hands-on work, you really can\u2019t be in the lab, you can\u2019t do lab work at all.\u201d</span>\r\n\r\n[caption id=\"attachment_15409\" align=\"alignnone\" width=\"300\"]<img class=\"size-medium wp-image-15409\" src=\"https://media-innovation.news/wp-content/uploads/2020/06/Screen-Shot-2020-06-03-at-09.28.35-300x168.png\" alt=\"\" width=\"300\" height=\"168\" /> MAL[/caption]\r\n\r\n<span style=\"font-weight: 400;\">Emerson\u2019s Lab, as opposed to Edison\u2019s, as its name suggests, is also associated with the research field of media archaeology.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cGenerally speaking, it\u2019s interested in getting at the life, even the \u2018consciousness\u2019 of media - trying to cut out human perspective to understand the life of the machine. And then understand how the life of the machine determines what and how you\u2019re able to create.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe other branch of media archaeology is interested in pursuing dead ends in technological development - so there\u2019s a part of it that\u2019s interested in the realm of the imagination - \u2018how would have things been different if we had pursued this little branch off the main line? Or how could things </span><i><span style=\"font-weight: 400;\">still </span></i><span style=\"font-weight: 400;\">be different?\u2019.\u201d</span>\r\n<h3>Changing the criteria for innovation</h3>\r\n<span style=\"font-weight: 400;\">Emerson is writing another book on this theme, titled </span><a href=\"https://loriemerson.net/category/other-networks/\"><i><span style=\"font-weight: 400;\">Other Networks</span></i></a><span style=\"font-weight: 400;\">. \u201cIt\u2019s something I bring into the classroom and try to explore - other configurations and networks that existed before the internet became what it is - I try to get students to reimagine how things could be different. \u2018What would a different internet look like?\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">One real example she describes are bulletin board systems that were around in the 1980s and the early 1990s, made up of just a few hundred people in a small area who wanted to share - and avoid long-distance call charges.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWhich I think produces something quite wonderful and not commercial, and much more oriented towards community. Interestingly enough, the online interactions led to in-person interactions, which I think is quite different from what we have nowadays.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThat\u2019s something I\u2019ve been trying to get my students to think about - \u2018what if we change our criteria for technological progress or development or innovation? And we\u2019re not just obsessed with speed and efficiency and having things right now?\u2019.</span>\r\n\r\n[caption id=\"attachment_15414\" align=\"alignnone\" width=\"300\"]<img class=\"size-medium wp-image-15414\" src=\"https://media-innovation.news/wp-content/uploads/2020/06/Screen-Shot-2020-06-03-at-12.03.19-300x171.png\" alt=\"\" width=\"300\" height=\"171\" /> MAL[/caption]\r\n\r\n<span style=\"font-weight: 400;\">\u201c\u2018What if we change the criteria and move towards something that\u2019s slower, more methodical and more cooperatively minded - so that we actually own the network infrastructure, rather than having a major conglomeration own it?\u2019.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Asked if her students like the idea, she says they \u201clove it, in principle\u201d. But they\u2019re as bound up in the speed of things as anyone else, keen to get things done and get a job.</span>\r\n<h3>Beyond man</h3>\r\n<span style=\"font-weight: 400;\">\u201cOne drawback to the way the humanities have thought about themselves has been the totalising push to always put the human front and centre - above and beyond the environment, nonhuman animals, all sorts of things - and of course this notion of human is also always almost \u2018white male\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo anything that unsettles that perspective, which media archaeology tries to do, I think is absolutely worthwhile. And, you know, we\u2019re staring down the barrel of an apocalypse and I don\u2019t think that yet more humanism is going to help us with that problem.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSo media archaeology and its method of trying to get outside of the human I think is really important and can be really effective.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">But she admits it has its problems. \u201cI think it can also be really problematic if people attempt to believe that\u2019s possible - I don\u2019t think it\u2019s possible to get outside of your human perspective.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnother, related problem, with media archaeology is that it can be very, deeply apolitical - it takes its interest in hardware so seriously that it can completely neglect the politics of humans going on all around them - and, again, neglects power and the fact this white male perspective dominates everything.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cYou\u2019ll notice when doing research in media archaeology there are hardly any women mentioned - as it turns out, there are lots of women doing media archaeology-like work - but a combination of the way people are defining media archaeology, and their own blindspots about the people who they tend to focus, which are the white, male German theorists, exclude all of those women.\"</span>\r\n\r\n[caption id=\"attachment_15418\" align=\"alignnone\" width=\"300\"]<img class=\"size-medium wp-image-15418\" src=\"https://media-innovation.news/wp-content/uploads/2020/06/Screen-Shot-2020-06-03-at-12.13.18-300x170.png\" alt=\"\" width=\"300\" height=\"170\" /> MAL: scavenger hunt event for teens involved in the CU Science Discovery program[/caption]\r\n\r\n<span style=\"font-weight: 400;\">Emerson says she\u2019s been lucky to carve out a space in her institution to do her work. \u201cPeople didn\u2019t really realise what we were doing until the MAL became established.\u201d The lab has a longstanding supporter in the shape of a local venture capitalist and gets some university funding - but she believes its unusual style means money isn\u2019t always forthcoming.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt does seem like, the bigger your budget the more freedom you have to innovate in a more open-ended way - but then the problem is - trying to figure out where the money comes from. I\u2019m just guessing there\u2019s no way to have a budget that big and make sure that all of your funding is ethically sourced.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">You can explore the Media Archaeology Lab </span><a href=\"https://mediaarchaeologylab.com/\"><span style=\"font-weight: 400;\">here</span></a><span style=\"font-weight: 400;\">.</span>\r\n<div class=\"wpb_column vc_column_container vc_col-sm-8\">\r\n<div class=\"vc_column-inner \">\r\n<div class=\"wpb_wrapper\">\r\n<div class=\"kleo_text_column wpb_content_element \">\r\n<div class=\"wpb_wrapper\">\r\n\r\nCONTACT\r\n\r\n<img class=\"alignnone size-medium wp-image-15429\" src=\"https://media-innovation.news/wp-content/uploads/2020/06/IMG_6746-300x225.jpg\" alt=\"\" width=\"300\" height=\"225\" />\r\n\r\nLori Emerson, founding director of the Media Archaeology Lab at the University of Colorado\r\n\r\nTwitter: <a href=\"https://twitter.com/loriemerson\">@loriemerson</a> <a href=\"https://twitter.com/mediarchaeology\">@mediarchaeology</a>.\r\n\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"The Media Archaeology Lab: letting people discover different possibilities for innovation","post_link":"https://media-innovation.news/media-lab/the-media-archaeology-lab-letting-people-discover-different-possibilities-for-innovation/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Media Archaeology Lab: letting people discover different possibilities for innovation\" width=\"300\" height=\"167\" src=\"https://media-innovation.news/wp-content/uploads/2020/06/Media-Archaeology-Lab-300x167.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs, Research projects","post_tags":"Boulder, Colorado, Feminist lab, Lori Emerson, Media archaeology, Media Archaeology Lab, media technology, THE LAB BOOK, University, University of Colorado","%_edit_lock%":"1612209281:1","%_edit_last%":"933","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"1320 Grandview Ave, Boulder, CO 80302, USA","%_wpgmp_location_city%":"Boulder","%_wpgmp_location_state%":"Colorado","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"40.0113303","%_wpgmp_metabox_longitude%":"-105.2754692","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"15426","%_kleo_title_checkbox%":"1","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Media labs, Research projects","taxonomy=post_tag":"Boulder, Colorado, Feminist lab, Lori Emerson, Media archaeology, Media Archaeology Lab, media technology, THE LAB BOOK, University, University of Colorado"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15406,"infowindow_disable":false},{"source":"post","title":"VRT Sandbox: leading the way on startup and media collaboration in Europe","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"VRT Sandbox: leading the way on startup and media collaboration in Europe\" width=\"300\" height=\"167\" src=\"https://media-innovation.news/wp-content/uploads/2020/05/VRT-Sandbox-300x167.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">VRT Sandbox: leading the way on startup and media collaboration in Europe</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            VRT is the public-service broadcaster for Belgium's Flemish community - but it also welcomes startups and scaleups through its doors with the promise of experience, exposure and even, perhaps, becoming an international export\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/vrt-sandbox-leading-the-way-on-startup-and-media-collaboration-in-europe/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"VRT is the public-service broadcaster for Belgium's Flemish community - but it also welcomes startups and scaleups through its doors with the promise of experience, exposure and even, perhaps, becoming an international export","address":"Auguste Reyerslaan 52 B, 1043 Schaarbeek, Belgium","location":{"lat":"50.8527379","city":"Schaarbeek","state":"Brussels Hoofdstedelijk Gewest","country":"Belgium","lng":"4.4023311","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/vrt-sandbox-leading-the-way-on-startup-and-media-collaboration-in-europe/","zoom":2,"extra_fields":{"post_excerpt":"VRT is the public-service broadcaster for Belgium's Flemish community - but it also welcomes startups and scaleups through its doors with the promise of experience, exposure and even, perhaps, becoming an international export","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>VRT Sandbox: leading the way on startup and media collaboration in Europe</h1>\r\n<span style=\"font-weight: 400;\">VRT\u2019s remit is technically limited to the 6.5 million Dutch speakers of northern Belgium - but the public-service broadcaster has spent years going above and beyond in the name of media innovation.</span>\r\n\r\n<span style=\"font-weight: 400;\"><a href=\"https://sandbox.vrt.be/\">VRT Sandbox</a>, one of a number of its <a href=\"https://innovatie.vrt.be/index.php/en\">innovation brand</a>s, has for five years been acting as a \u201cfront door for startups and scale ups in media\u201d, according to its head Peter de Paepe, a former radio producer and presenter.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cEverybody who thinks that it might be interesting to work with VRT can just knock on the door and say \u2018OK, this is who I am and I would like to work together with you, with this brand\u2019\u201d, he explains. \"And of course, as a company, we\u2019re glad that we can work with the most promising media startups.\"</span>\r\n\r\n<span style=\"font-weight: 400;\">After getting lots of approaches from startups and scaleups keen to test their content or tech solutions, de Paepe set up a \u2018matchmaking\u2019 service. Now, he sits down with more than 100 companies each year, as well as staff from VRT\u2019s 11 TV, radio and OTT brands, to understand what each would want from a match.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe offer startups a test for three to four months. Why? Because it's very clear. It's very short. It is doable for the brand on the VRT side and for the startup. That also means sometimes you have to define a use case that\u2019s rather basic. So that's a bit of a challenge.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">In other organisations, this kind of collaboration might take four to six months to get started, once you get your foot in the door, of course. But VRT Sandbox aims to get started in four to six weeks.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe identify what a startup is doing. Then we try to figure out, \u2018OK, what can it mean for the brands that we have?\u2019. Then we organise \u2018dating\u2019 and give an MOT to the brands. The startup needs to have something that works and can be implemented right away.\u201d</span>\r\n<h3><span style=\"font-weight: 400;\">Matchmakers, not project makers</span></h3>\r\n<span style=\"font-weight: 400;\">Every year up to 20 companies, half Flemish, half international, that are working in media content, tech or edtech test a minimum-viable product with one of VRT\u2019s teams, a workforce of 2,000. One such match has seen startups working with Studio Brussels, VRT\u2019s youth radio channel, on an end-of-year multimedia event that reaches more than 1 million people every day.</span>\r\n\r\n<span style=\"font-weight: 400;\">Alongside a specific call in the \u201cdifficult\u201d area of edtech, which supports VRT\u2019s wider strategic goal to get good content into education, VRT is on the hunt for companies working on \u2018interaction and co-creation\u2019, \u2018personalisation, data and A.I\u2019, \u2018fighting fake news\u2019 and \u2018accessibility\u2019. The latter is another key focus for the public-service broadcaster, designed to help it reach every Flemish person.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe are not project makers. We link the startup to a brand, and then, if we have found the right use case and the right match, it's the people of the brand and the startup that work together. And we are just in between to guide it a little bit.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThat also means sometimes we see things falling apart. But we are not there to always convince people to further work on these projects.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">The Sandbox has a physical space where startups can base themselves and where VRT staff can make suggestions for new projects. \u201cThat works very well and it\u2019s very nice to see that we are sort of a central innovation place where all of the brands come and know, \u2018OK, this is where we can discuss new plans with startups'.\u201d\u00a0</span>\r\n<h3><span style=\"font-weight: 400;\">Closed wallet</span></h3>\r\n<span style=\"font-weight: 400;\">VRT Sandbox operates a \u2018closed wallet\u2019 model - startups don\u2019t get cash, but they get experience in a \u2018safe environment\u2019, expert coaching, exposure and, sometimes, a deal with VRT - or, even, help getting their next paid gig.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe startups have access to our internal network, not only people, but they also get to see how we work and our technological stack. That's also a reason why they are very keen to come.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnd you have the dissemination. That means that we try to see, after four months, \u2018what did we learn? Can we spread the things that we learned?\u2019. We question the people very well on the VRT side and startup side to understand \u2018what did they learn and what do they want to do after this?\u2019.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">To further amplify this, de Paepe\u2019s team runs two large events each year - one for the local media circuit and one, integrated into Media Fast Forward, that hosts 2,000 participants from across Europe and offers a \u2018startup street\u2019 showcase for more than 60 companies. </span><span style=\"font-weight: 400;\">Along with offering startups the opportunity to travel to other events across the world, this takes the bulk of his \u20ac160,000 yearly budget, plus a small team, equivalent to four full-time workers.</span>\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone wp-image-15395 size-large\" src=\"https://media-innovation.news/wp-content/uploads/2020/05/VRT-Sandbox-startup-1024x572.png\" alt=\"\" width=\"1024\" height=\"572\" /></span>\r\n\r\n<span style=\"font-weight: 400;\">One successful Sandbox project, Theoplayer, has become the default media player across all VRT\u2019s websites. \u201cThey tested four years ago with a minimum-viable product. They are now a company with about 120 people and have offices in New York and San Francisco.\u201d</span>\r\n<h3><span style=\"font-weight: 400;\">Startups changing media practice</span></h3>\r\n<span style=\"font-weight: 400;\">Another, Voizupp, has created fundamental change at the broadcaster by offering an app-based integration, alongside a data dashboard that, for the first time, enables radio teams to see who\u2019s listening, for how long, and more, so they can take that data into the discussions around the shows they make.</span>\r\n<blockquote><span style=\"font-weight: 400;\">\u201cSometimes people say, \u2018you're always testing with startups, and on a very small scale - what is the importance for a big company as VRT?\u2019. And then I give them the example of Voizupp, how you can make not only the technological change, but also a change in minds, how people make their radio programmes or TV programmes.\u00a0</span></blockquote>\r\n<span style=\"font-weight: 400;\">\u201cAnd, of course, you have to accelerate with other teams and then say, \u2018OK, how can we find a budget to make it bigger?\u2019. But the start comes from or can come from a startup. So that's why I think that often it works very well.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">After two years testing with Flemish startups, and with international interest coming in, de Paepe decided to see about making the Sandbox bigger - and is now focused on being able to offer startups and scaleups the chance to truly go global.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOK, can we reproduce this model to other media companies?,\u201d he asked. \u201cWe went to the BBC and Media City Bergen and Red Bull Media House. We explained how we work and why we thought it was a good idea. And, actually, they decided very fast to do it. It's not an exact copy, but the idea of innovating together with startups and scaleups, learning very fast and sharing this expertise. That's what these companies do.\u201d</span>\r\n<h3><span style=\"font-weight: 400;\">Scaling up the opportunity</span></h3>\r\n<span style=\"font-weight: 400;\">They now have 18 public and private media companies in the <a href=\"https://sandbox.vrt.be/media-innovation\">Sandbox Hub</a>, who meet monthly to share what they\u2019re learning. \u201cAlmost every country in Europe is represented. After a startup collaboration with VRT, we introduce startups to another media party like NPO [the Dutch public broadcaster]. And then they do a test there or they just get a paid introduction and then they are launched European.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone wp-image-15394 size-large\" src=\"https://media-innovation.news/wp-content/uploads/2020/05/Sandbox-Hub-1024x572.png\" alt=\"\" width=\"1024\" height=\"572\" /></span>\r\n\r\n<span style=\"font-weight: 400;\">The final piece of the puzzle, it seems, was found just over a year ago with the creation of a \u20ac10 million, joint-venture innovation fund, Media Invest Vlaanderen [Media Invest Flanders], with local investment firm PMV.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOf course, a fund is a new way of bringing cash in for VRT. But the main reason we thought it was a good idea was because, if these startups wanted to grow internationally, they would need investment money to grow.\u00a0</span>\r\n<blockquote><span style=\"font-weight: 400;\">\u201cIf you compare it with fintech, for example, there, it's very easy to find money, but in media, it's rather difficult to find \u20ac1 million. So this is a fund that can help them. It's mainly for professionalising the ecosystem. The last one we funded is actually Theoplayer. They had a round of \u20ac6 million and we put it in \u20ac1 million.\u201d</span></blockquote>\r\n<span style=\"font-weight: 400;\">So why is a public-service broadcaster from the north of Belgium so keen on building a stronger media innovation ecosystem across Europe?</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt's something that is in our DNA. We really want to be one of the most innovative media companies of Europe. The fact that we are very central and that we have to network is, of course, one of the things that we are doing already for 30, 40 years. So that's nothing new.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWhat is new is that we, from a perspective of the startups, for them it was very important to immediately work in an international environment. And that meant that we had to, for example, communicate in English. That sounds very easy. But we had to struggle to make that happen.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">He\u2019s also very keen to make sure Europe has the companies it needs to compete with the US and Asia. </span>\r\n\r\n<span style=\"font-weight: 400;\">And, while de Paepe admits this innovation work hasn\u2019t, so far, spurred a huge increase in the number of local media startups, VRT\u2019s approach is sought after in more unexpected places.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cA lot of other companies, and not only media companies, are coming and looking to us, for example, the national lottery company and BPost, the company that delivers the post in Belgium. So what I see is that people are now more and more convinced that the way that we innovate might be a useful way to innovate. We never pretend that\u2019s the only one way, or the only good way. We just explain how we do it.\u201d</span>\r\n\r\n&nbsp;\r\n\r\nCONTACT\r\n\r\n<img class=\"wp-image-15398 size-medium\" src=\"https://media-innovation.news/wp-content/uploads/2020/05/Peter-de-Paepe-e1588933088128-300x276.jpeg\" alt=\"\" width=\"300\" height=\"276\" />\r\n\r\nPeter de Paepe, head of VRT Sandbox\r\nTwitter:\u00a0<a href=\"https://twitter.com/peterdepaepe\">@peterdepaepe</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_column_text]\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>[/vc_column_text][/vc_column][/vc_row]","post_title":"VRT Sandbox: leading the way on startup and media collaboration in Europe","post_link":"https://media-innovation.news/media-lab/vrt-sandbox-leading-the-way-on-startup-and-media-collaboration-in-europe/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"VRT Sandbox: leading the way on startup and media collaboration in Europe\" width=\"300\" height=\"167\" src=\"https://media-innovation.news/wp-content/uploads/2020/05/VRT-Sandbox-300x167.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"Belgium, Flanders, Peter de Paepe, Sandbox, Sandbox Hub, VRT, VRT Sandbox","%_edit_lock%":"1634817956:931","%_edit_last%":"933","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Auguste Reyerslaan 52 B, 1043 Schaarbeek, Belgium","%_wpgmp_location_city%":"Schaarbeek","%_wpgmp_location_state%":"Brussels Hoofdstedelijk Gewest","%_wpgmp_location_country%":"Belgium","%_wpgmp_metabox_latitude%":"50.8527379","%_wpgmp_metabox_longitude%":"4.4023311","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"15393","%_kleo_title_checkbox%":"1","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Media labs","taxonomy=post_tag":"Belgium, Flanders, Peter de Paepe, Sandbox, Sandbox Hub, VRT, VRT Sandbox"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15391,"infowindow_disable":false},{"source":"post","title":"Altinget: robot, engagement and constructive political journalism innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Altinget: robot, engagement and constructive political journalism innovation\" width=\"300\" height=\"143\" src=\"https://media-innovation.news/wp-content/uploads/2020/04/Screen-Shot-2020-04-01-at-12.47.06-300x143.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Altinget: robot, engagement and constructive political journalism innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Altinget is building engaged communities around politics across Denmark and Sweden - and making money from it to experiment.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/altinget-robot-engagement-and-constructive-political-journalism-innovation/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Altinget is building engaged communities around politics across Denmark and Sweden - and making money from it to experiment.","address":"Copenhagen, Denmark","location":{"lat":"55.6760968","city":"Copenhagen","country":"Denmark","lng":"12.5683372","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/altinget-robot-engagement-and-constructive-political-journalism-innovation/","zoom":2,"extra_fields":{"post_excerpt":"Altinget is building engaged communities around politics across Denmark and Sweden - and making money from it to experiment.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1><span style=\"font-weight: 400;\"><b>Altinget: robot, engagement and constructive political journalism innovation</b></span></h1>\r\n<span lang=\"en-US\">Kristoffer Hecquet is head of the rather modestly named \u2018projects department\u2019 at\u00a0</span><a href=\"https://www.altinget.dk/\" target=\"_blank\" rel=\"noopener noreferrer\" data-auth=\"NotApplicable\"><span lang=\"en-US\">Altinget</span></a><span lang=\"en-US\"> \u2013 and with only two full-time staff,\u00a0on the face of it, it might appear a rather modest operation.</span>\r\n\r\n<span style=\"font-weight: 400;\">Behind the scenes though, Hecquet has spent 10 years fundraising for this \u2018media lab\u2019 to exist within Denmark\u2019s digital-first, politics-first Altinget - the Danish equivalent of Politico.</span>\r\n\r\n\u201cI fundraised my own position. That\u2019s how it developed,\u201d he says, explaining that he joined the business a decade ago as an intern. Now he heads a small team with a portfolio of different editorial innovation projects. \u201cIt\u2019s 100 per cent financed by external funding.\r\n\r\n<span style=\"font-weight: 400;\">\u201cIts raison d'\u00eatre is to develop digital editorial projects that support the existing business and it also works to develop new editorial products that have economic potential.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Editorial staff at Altinget work along political verticals - which are chosen to be closely aligned to government departments - whether that\u2019s education or agriculture. From here, they contribute to a common frontpage that\u2019s financed by advertising and has more than 100,000 Danish subscribers.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">The in-depth reporting within each vertical is then paid for by subscribers, representing up to 80 per cent of revenues, from political professionals, politicians and other interest groups. \u201cAll organisations or persons who need influence in this specific policy area\u201d, Hecquet explains.</span>\r\n<h3><span style=\"font-weight: 400;\">Finding a niche</span></h3>\r\n<span lang=\"en-US\">The most regular innovation work his team does is leading the development of \u2018Voter Advice Applications\u2019 (VAAs) that help people make decisions about who to vote for.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Here, Altinget has a big focus on collaboration and that means working with some of the Nordics\u2019 biggest media players, including the public-service broadcasters in Denmark and Sweden, DR and STV, as well as the Norwegian press agency NTB. As innovation projects go, these have long lead times and are easily mapped as they align to regular political cycles.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cSVT and DR are pretty powerful because people trust them, they are everywhere and they\u2019re free. We are strictly neutral, otherwise we wouldn\u2019t be able to serve our readers with the purpose that we have. That\u2019s a good base for us to build a VAA because we don\u2019t have any bias. If we would have, we wouldn\u2019t have a business.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe most important thing here is to be very careful. We have a big dialogue with our customers on how to make sure the VAAs are politically neutral. We have a strict system of testing - including our journalists on each vertical - so we have a big battery of competence.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThen we also have scientists that look through statements and we test on users as well. We make tests and simulations - both before and after - and that\u2019s pretty important work.</span>\r\n\r\n<span style=\"font-weight: 400;\">After already expanding its business into Sweden, it\u2019s these VAAs that present an opportunity for Altinget to expand into other countries, Hecquet says.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt\u2019s also a huge dataset on all the candidates - what they think about the political stances - so it\u2019s very good for data journalism.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">When he\u2019s not helping negotiate the next long-term deal for a VAA, he\u2019s working up other editorial innovation projects that could ultimately support the bottom-line. Hecquet has won funding from Google DNI, and various national and European political bodies, to continue this work.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt\u2019s based on dialogue with the editorial team - sometimes it\u2019s me pushing the idea, sometimes it\u2019s the other way around. Quite a heavy focus now is to support our existing journalism with data, discovering data, covering statistics on political parties and polls, but also producing semi-auto-generated content. When we\u2019re working on robot journalism it\u2019s very short term - it all depends on what\u2019s also on the table.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe also work a lot with structured journalism - one big project here is called the \u2018decision chain\u2019, which we have worked out in both Sweden and Denmark with support from DNI.\u00a0</span>\r\n<h3><span style=\"font-weight: 400;\">Opening up government data</span></h3>\r\n<span style=\"font-weight: 400;\">\u201cIt\u2019s based on public open data from the government and parliaments in Denmark and Sweden. From it, we make this \u2018legislative chain\u2019 to create auto-generated, mini-articles from all the legislative steps in the parliament. </span>\r\n\r\n<span style=\"font-weight: 400;\">\"They spend a lot of money to make their open data available, so they\u2019re so happy when finally someone uses it.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">The result is a visual timeline that updates when a given piece of legislation takes another step through the relevant process, complemented by longer pieces written by Altinget journalists.</span>\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone wp-image-15363 size-medium\" src=\"https://media-innovation.news/wp-content/uploads/2020/04/Altinget-Decision-Chain-300x191.png\" alt=\"\" width=\"300\" height=\"191\" /></span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOf course, we now automate some processes that we did manually before, which is very good, but we also put an extra dimension to our journalism. When you read an article - even though you\u2019ve read the full article - it\u2019s not the end product. It\u2019s part of a bigger whole.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe latest thing in the Swedish version is - when logging in, you can subscribe to one of these strings - so every time there is a new article or a new element from the data, you get a notification. So you\u2019re always alert on the specific law proposal that you follow.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIn Sweden it has particular value because there\u2019s no other place where you bind together data from the government and the parliament.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Altinget worked with data journalism experts Journalism++ during the development phase of this product, \u201cfor their competence on open data\u201d, but further developments are done in house.</span>\r\n<h3><span style=\"font-weight: 400;\">Getting dialogue with readers</span></h3>\r\n<span style=\"font-weight: 400;\">Hecquet also won Google DNI funding for pursuing more \u2018engaged journalism\u2019 among journalists and readers - which will see them building a new digital platform.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cA few years ago we introduced very organised debate entries in the verticals - and it\u2019s now more or less getting half of the traffic - because it really turned into creating the political community around these sectors. This is just as important as the journalism.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWhen we have a debate, on how to treat groundwater in the farming sector for example, we take experts, the government, the opposition, the farmers themselves, the environmental organisations - the whole spectre of interest groups. We create the platform for them to have an orderly discussion.\u00a0</span>\r\n\r\n<b><img class=\"alignnone size-medium wp-image-15364\" src=\"https://media-innovation.news/wp-content/uploads/2020/04/Altinget-Debate-300x163.png\" alt=\"\" width=\"300\" height=\"163\" /></b>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBefore, we spent a lot of time persuading them to participate, but now they more or less come themselves to be a part of the discussion. They have to be at Altinget to stay informed because all the others do it.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt\u2019s hard to find this kind of dialogue anywhere else unless you meet the person live in the parliament building. </span><span style=\"font-weight: 400;\">They do it because they need to - if they need political influence, then they have to read our newspaper.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Altinget has also taken a step into constructive journalism, which is resulting in the creation of a civil society \u2018knowledge center\u2019. Hecquet got the initial work to start serving this audience privately funded for three years, despite it not being a standard Altinget vertical.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt\u2019s a homepage where we gather information about what civil society does - we have a database on the science of civil society - but the most important thing is our toolbox. It\u2019s a weekly newsletter with constructive journalism articles on things like \u2018how to run your organisation when you have coronavirus\u2019. It\u2019s not news, but a newsletter with tools.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe also use the \u2018knowledge center\u2019 to try out things, test some new designs, or ideas such as \u2018how we can do online education?\u2019, things we haven\u2019t tried in other parts of the organisation, but we can try it there because we have funding.\"</span>\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone size-medium wp-image-15365\" src=\"https://media-innovation.news/wp-content/uploads/2020/04/Altinget-Civil-Society-Toolbox-292x300.png\" alt=\"\" width=\"292\" height=\"300\" /></span>\r\n\r\n<span style=\"font-weight: 400;\">Just launching in 2020 is a political education resource for teachers to share Altinget content with pupils. This is the result of a three-year funded project \u2013 youth media on politics and society focused on getting 13 to 18-year-olds more engaged.</span>\r\n\r\n<span style=\"font-weight: 400;\">One of the next things to tick off his to-do list is a rebrand, Hecquet explains, taking on the all-important \u2018media lab\u2019 nametag to make sure people across the organisation know what project work is being done - and why.</span>\r\n<h3><span style=\"font-weight: 400;\">Internal negotiation</span></h3>\r\n<span style=\"font-weight: 400;\">Altinget launched in 2000 and has grown from covering six verticals allied to Danish political departments to reporting on more than 20 across two nations. Since Hecquet started, the staff has grown from around 20 to 150 and Altinget also bought the older Scandinavian political title Monday Morning, integrating IT, sales and more for greater efficiency.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe\u2019re in the process of rebranding as we\u2019ve had shifting leadership and the organisation has grown a lot. Media lab would probably be the best term from what we do - but if that\u2019s accepted in the rest of the organisation is unsure. That\u2019s how we\u2019re beginning to rebrand ourselves internally and, when we have to explain what we do, that\u2019s most often the term that comes up.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">But he\u2019s also keen to get a developer into his team long-term.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe are pretty agile and staffing depends a lot on the project. The reason why it\u2019s possible for me to get things done is that I have a budget. I can prioritise the IT team to make a certain thing in a certain amount of time and they will prioritise this because I have a budget.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBut we\u2019re often delayed because of a bottleneck \u2013 developers are always in demand. I think that it will help a lot in digital development, to work more closely with developers, to have more space to experiment.\u201d</span>\r\n\r\n&nbsp;\r\n\r\nCONTACT\r\n\r\n<img class=\"alignnone size-medium wp-image-15368\" src=\"https://media-innovation.news/wp-content/uploads/2020/04/Kristoffer-Hecquet-300x225.jpg\" alt=\"\" width=\"300\" height=\"225\" />\r\n\r\nKristoffer Hecquet, head of projects\r\nTwitter: <a href=\"https://twitter.com/hecquetk\">@hecquetk</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Altinget: robot, engagement and constructive political journalism innovation","post_link":"https://media-innovation.news/media-lab/altinget-robot-engagement-and-constructive-political-journalism-innovation/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Altinget: robot, engagement and constructive political journalism innovation\" width=\"300\" height=\"143\" src=\"https://media-innovation.news/wp-content/uploads/2020/04/Screen-Shot-2020-04-01-at-12.47.06-300x143.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"automation, constructive journalism, Denmark, engaged journalism, Google DNI, political journalism, Sweden","%_edit_lock%":"1588933268:933","%_edit_last%":"933","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Copenhagen, Denmark","%_wpgmp_location_city%":"Copenhagen","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"Denmark","%_wpgmp_metabox_latitude%":"55.6760968","%_wpgmp_metabox_longitude%":"12.5683372","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"15361","%_wp_old_slug%":"altinget-automation-engagement-and-constructive-political-journalism-innovation","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Media labs","taxonomy=post_tag":"automation, constructive journalism, Denmark, engaged journalism, Google DNI, political journalism, Sweden"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15356,"infowindow_disable":false},{"source":"post","title":"MediaLab EAFIT: Colombian perspective on media innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"MediaLab EAFIT: Colombian perspective on media innovation\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2020/03/Workshop_Foto_1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">MediaLab EAFIT: Colombian perspective on media innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Media innovation methodologies are often created in well-developed media markets, but do they function equally well in different contexts around the world? We spoke to a Colombian university media lab to find out how it approaches its innovation projects.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/medialab-eafit-colombian-perspective-on-media-innovation/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Media innovation methodologies are often created in well-developed media markets, but do they function equally well in different contexts around the world? We spoke to a Colombian university media lab to find out how it approaches its innovation projects.","address":"Carrera 49, n\u00famero 7 sur 50, Medell\u00edn, Antioquia, Colombia","location":{"lat":"6.199547999999999","city":"Medell\u00edn","state":"Antioquia","country":"Colombia","lng":"-75.57934","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/medialab-eafit-colombian-perspective-on-media-innovation/","zoom":2,"extra_fields":{"post_excerpt":"Media innovation methodologies are often created in well-developed media markets, but do they function equally well in different contexts around the world? We spoke to a Colombian university media lab to find out how it approaches its innovation projects.","post_content":"[vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1>MediaLab EAFIT: Colombian perspective on media innovation</h1>\r\n<em>Media innovation methodologies are often created in well-developed media markets, but do they function equally well in different contexts around the world? We spoke to a Colombian university media lab to find out how it approaches its innovation projects.</em>\r\n\r\nThe <a href=\"http://www.eafit.edu.co/medialab/Paginas/inicio.aspx\">MediaLab EAFIT</a> is part of the department of communication studies at Universidad EAFIT, located at the university\u2019s campus in Medell\u00edn, Colombia. The lab was founded in 2009, with modest resources (second-hand computers and one teacher), to explore digital convergence. This first iteration of the lab investigated virtual worlds (Second Life at the time) and emerging media formats, such as video blogs and live blogging.\r\n\r\n\u201cIn the beginning it was very informal, and the activities and topics were based on people\u2019s personal interests,\u201d says Mar\u00eda Isabel Villa Montoya, Coordinator of the master\u2019s degree in Transmedia Communication at Universidad EAFIT.\r\n\r\nIn 2012 the lab\u2019s status within the university was formalised, and it was given a dedicated room at the campus. The same year it started its own YouTube channel <a href=\"https://www.youtube.com/user/medialabeafit\">MediaLab TV</a>, and launched projects exploring media literacy and transmedia storytelling. The year after the EAFIT university launched an MA in transmedia communications, closely linked to the MediaLab.\r\n\r\nCurrently the lab has two classrooms dedicated to students\u2019 work, with a new research space opening in 2020. A new BA on interactive design, also connected to the lab, will also start this year.\r\n\r\nToday the lab organises its work based on four strategic pillars:\r\n<ul>\r\n \t<li><strong>Research</strong> into new technologies, their applications, and new methodologies</li>\r\n \t<li><strong>Teaching and learning</strong> using new, decentralized, open and collaborative methods</li>\r\n \t<li>Transmedia <strong>content creation</strong> for new platforms</li>\r\n \t<li><strong>Social innovation</strong> that aims to create solutions to citizens\u2019 problems.</li>\r\n</ul>\r\nThe last pillar relates to societal issues that explore topics outside the traditional media sphere: \u201cWe don't think that technology per se is important. Rather, technology exists for people,\u201d Villa Montoya says. \u201cSo we work with real people on real problems to develop real solutions for them.\u201d\r\n<h3>Investigating drug traffic</h3>\r\nGiven the lab\u2019s status within Universidad EAFIT, the university\u2019s students are heavily involved in the work of MediaLab: over 200 students participate in the lab\u2019s projects.[/vc_column_text][vc_gallery type=\"grid\" images=\"15346,15347\"][vc_column_text]Some of the initiatives relate to the MediaLab\u2019s expertise in transmedia. For instance, TigoUne, a telecommunications company, contracted the lab in 2017 to develop a transmedia strategy in order to redesign its social responsibility strategy aimed at the creative and responsible use of technology in Colombia. \u201cWe developed a big strategy for the whole country, and it\u2019s been one of our biggest projects so far,\u201d Villa Montoya says.\r\n\r\nThe lab also works on journalistic projects, sometimes in collaboration with the university\u2019s courses on digital journalism as part of the bachelor\u2019s degree on Communications. For instance, a project called <a href=\"http://www.eafit.edu.co/medialab/lineas-accion/Paginas/Narcotour-%E2%80%93-El-lado-B-de-la-historia-del-narcotr%C3%A1fico-en-Medell%C3%ADn.aspx\">Narcotour</a> investigated drug traffic and the impact of drug gangs in the city of Medell\u00edn.\r\n\r\nFor this project, the lab collaborated with local and national news publishers in the country, such as the newspaper El Colombiano and the radio station Caracol. \u201cThere are a lot of victims and families with tragic stories, and we wanted to tell their stories using new technologies,\u201d Villa Montoya says.\r\n\r\nThe lab aims to produce similar investigative stories every year, often with support from external media companies. Although such collaborations are important, Villa Montoya says that the differences between commercial media companies and an academic research lab can sometimes get in the way.\r\n\r\n\u201cMedia companies in the region are just waking up to the convergence and digitalisation,\u201d she says. \u201cThey also need to move fast, and as an academic lab we don\u2019t necessarily have enough resources to do that.\u201d\r\n<h3>Mapping media labs around the world</h3>\r\nIn order to explore the highly complex ecosystem of media innovation, the MediaLab EAFIT has an ongoing project to identify and categorise media labs globally. Currently its <a href=\"http://www.eafit.edu.co/medialab/proyectos-en-curso/Paginas/sistematizacion-medialab-eafit.aspx\">database</a> includes over 150 labs, categorised in three groups (academic, commercial and social) and classified based on their activities (ranging from research and training to product development and consultation).\r\n\r\nThis mapping initiative is based on online research, accompanied by interviews with the identified labs. MediaLab EAFIT is preparing to publish a paper about the results later this year, but some findings already give an indication of the state of the global network of media labs.\r\n\r\nGeographically, the majority of media labs are based in Europe, followed by North America. However, the research finds that media innovation units are a global phenomenon, and labs are increasingly also appearing in Latin America, Asia, Africa, and Oceania.\r\n\r\nThe study also found that the majority of labs worldwide operate in an academic context, although surprisingly academic media labs are not prominent in the literature. Nonetheless, most labs concentrate on content production and technology development, with research and teaching taking a less important role.\r\n\r\nAs for media labs operating in a commercial context, they mostly focus on developing new products and business models to adapt to the changing news environment and digital convergence, while also developing new formats that aim to attract new audiences.\r\n\r\nFinally, social labs, usually ran by governments or non-governmental organisations, try to respond to challenges in their communities, for example by organising living labs and hackerspaces, Villa Montoya explains. Typically the aim is to address societal issues such as promoting media literacy by employing new technologies and bringing different professionals together. Examples include <a href=\"https://www.medialab-prado.es/\">Medialab Prado</a> in Madrid and the <a href=\"https://www.mintic.gov.co/portal/inicio/English-overview/Vive-Digital/\">Vive Digital</a> initiative, which has set up many labs in the Colombian countryside.\r\n<h3>Colombian perspective on innovation</h3>\r\nIn terms of innovation methodologies, Villa Montoya says that the MediaLab EAFIT uses a variety of methods on a case-by-case basis. However, based on her experience, methodologies that are created in first-world countries do not always work in different environments.\r\n\r\n\u201cIn developing countries such as Colombia, we have a lot of problems with methodologies. We don't have the same resources, or the same context, that is sometimes needed for the methodology to be applied.\u201d[/vc_column_text][vc_gallery type=\"grid\" images=\"15348,15349\"][vc_column_text]This means that methodologies need to be adapted and new working methods created: \u201cWe use a lot of legos and post-its, and although we use agile methodologies, for example, I don\u2019t think they are applied in a \u2018pure\u2019 way,\u201d she says. \u201cThey are applied in a more Latin American way!\u201d\r\n\r\nAccording to Villa Montoya, her counterparts in developed countries tend to have focused lines of research, and western labs often concentrate on narrowly defined topics. \u201cWe have to work in a more reactive manner. We have to adapt based on our funding sources, so we have to be able to work in many contexts,\u201d she says. \u201cIt\u2019s important to be really multifaceted and able to work in many fields, and it makes it really difficult to specialize.\u201d\r\n\r\nAs for MediaLab\u2019s future plans, Villa Montoya is particularly interested in virtual reality and how VR can change the relationship between the content and the consumer. \u201cIt's a big shift in the narrative style, because it forces you to put yourself in the audience\u2019s shoes when you construct stories in VR.\u201d\r\n\r\nFinally, the modest beginnings of the MediaLab EAFIT have taught Villa Montoya that a dedicated space and resources are secondary when it comes to starting a media lab \u2013 what you need is the right attitude, an open mind and a wish to develop new things.\r\n\r\n\u201cI think that it\u2019s a mistake to start with worrying about the place or the budget. It\u2019s much more important to think about the meaning of what you are doing.\u201d\r\n\r\nShe says that many labs focus excessively on the technology when solving problems, but often the source of the problem arises from human issues. \u201cMy advice is not to start with technology but to put your focus on the human problem. And then use technology to solve that problem.\u201d\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone size-medium wp-image-15344\" src=\"https://media-innovation.news/wp-content/uploads/2020/03/maria-isabel-villa-2016-1-200x300.jpg\" alt=\"\" width=\"200\" height=\"300\" />\r\n\r\nMar\u00eda Isabel Villa Montoya, Coordinator of the master\u2019s degree in Transmedia Communication, Universidad EAFIT\r\n\r\nLinkedIn: <a href=\"https://co.linkedin.com/in/mar%C3%ADa-isabel-villa-montoya-08650531\">Mar\u00eda Isabel Villa Montoya</a>[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"MediaLab EAFIT: Colombian perspective on media innovation","post_link":"https://media-innovation.news/media-lab/medialab-eafit-colombian-perspective-on-media-innovation/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"MediaLab EAFIT: Colombian perspective on media innovation\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2020/03/Workshop_Foto_1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"","%_edit_lock%":"1615298906:931","%_edit_last%":"931","%_thumbnail_id%":"15345","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Carrera 49, n\u00famero 7 sur 50, Medell\u00edn, Antioquia, Colombia","%_wpgmp_location_city%":"Medell\u00edn","%_wpgmp_location_state%":"Antioquia","%_wpgmp_location_country%":"Colombia","%_wpgmp_metabox_latitude%":"6.199547999999999","%_wpgmp_metabox_longitude%":"-75.57934","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"","taxonomy=category":"Media labs","taxonomy=post_tag":""},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15343,"infowindow_disable":false},{"source":"post","title":"NRKbeta: public service media innovation for the 21st century","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NRKbeta: public service media innovation for the 21st century\" width=\"300\" height=\"181\" src=\"https://media-innovation.news/wp-content/uploads/2020/03/NRKbeta-Venn-Diagram-300x181.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">NRKbeta: public service media innovation for the 21st century</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            NRKbeta has spent more than a decade developing its expertise where media, technology and society meet - to help Norway's public service broadcaster, and now the wider Norwegian media - give the people what they need.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/public-service-media-innovation-21st-century/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"NRKbeta has spent more than a decade developing its expertise where media, technology and society meet - to help Norway's public service broadcaster, and now the wider Norwegian media - give the people what they need.","address":"Bj\u00f8rnstjerne Bj\u00f8rnsons plass 1, 0340 Oslo, Norway","location":{"lat":"59.93551300000001","state":"Oslo","country":"Norway","lng":"10.7206105","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/public-service-media-innovation-21st-century/","zoom":2,"extra_fields":{"post_excerpt":"NRKbeta has spent more than a decade developing its expertise where media, technology and society meet - to help Norway's public service broadcaster, and now the wider Norwegian media - give the people what they need.","post_content":"[vc_row][vc_column width=\"1/6\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>NRKbeta: public service media innovation for the 21st century</h1>\r\n<span style=\"font-weight: 400;\">As media labs go, </span><a href=\"https://nrkbeta.no/\"><span style=\"font-weight: 400;\">NRKbeta</span></a><span style=\"font-weight: 400;\">, from the Norwegian public service broadcaster, pitches itself less as a </span><i><span style=\"font-weight: 400;\">lab</span></i><span style=\"font-weight: 400;\">, more as an innovation service for 3,500 staff working on behalf of 5.3 million people spread across the country\u2019s vast, mountainous geography.</span>\r\n\r\n<span style=\"font-weight: 400;\">Anders Hofseth has worked in this team for a decade and he\u2019s still a part-time journalist for the <a href=\"https://nrkbeta.no/\">nrkbeta.no</a> blog, where NRK\u2019s insight and innovation team started, but now he also acts as an internal, strategic advisor to the octogenarian organisation.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe initial opportunity was given to us in around 2006. It started out as a blog because that was something people did in 2006. Several of us had private blogs writing about things we were thinking about and doing. The question was asked - \u2018shouldn\u2019t this be something that is part of our organisation?\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe experimented a lot with publishing in the early days. Slowly that\u2019s matured into a technology and media vertical for NRK and now we\u2019re specialising - some of our team are writing, some doing R&amp;D, some advising the organisation. It made sense that it happened like that 15 years ago, but maybe wouldn\u2019t play out the same today.\u00a0</span>\r\n<h3>Asking tough questions</h3>\r\n<span style=\"font-weight: 400;\">\u201cOur remit is to ask uncomfortable questions, in a constructive way, of course. We understand the point of public service. We understand how the media works, how a lot of technology works and our role in society. We are able to say things that we need to say and know who to say it to.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201c</span><span style=\"font-weight: 400;\">When people ask me what I do, the short answer is - I try to understand change on behalf of the Norwegian Broadcasting Corporation.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Hofseth, who was the <a href=\"https://reutersinstitute.politics.ox.ac.uk/people/anders-hofseth\">inaugural Google Digital News Fellow</a> at the Reuters Institute at Oxford University back in 2016, eschews the \u2018media lab\u2019 label.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe used to call ourselves the \u2018sandbox\u2019 of NRK. Doing things that maybe shouldn\u2019t be done by the wider organisation before being tested first.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe were never built. We were just given permission to do things a long time ago. And the organisation sees it makes sense to let us do our thing. But we do have a small physical space and a publishing platform.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">He also emphasises that their team of seven works at the intersection of technology, media </span><i><span style=\"font-weight: 400;\">and society</span></i><span style=\"font-weight: 400;\">, the latter deeply informed by the public service remit of the wider organisation.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe reason we\u2019re here is for the audience - a big measurement for us is - \u2018what does the audience want?\u2019, not \u2018what do we want?\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cIt\u2019s a Venn diagram - technology has no value in itself, neither does media - where they meet society is where they change things and where we work.</span>\r\n\r\n[caption id=\"attachment_15319\" align=\"alignnone\" width=\"300\"]<img class=\"size-medium wp-image-15319\" src=\"https://media-innovation.news/wp-content/uploads/2020/03/Screen-Shot-2020-03-16-at-09.54.14-300x180.png\" alt=\"\" width=\"300\" height=\"180\" /> Where NRKbeta works[/caption]\r\n\r\n<span style=\"font-weight: 400;\">\u201cNRK in general is in a very good position as media companies go - it reaches 89 per cent of the population daily - including people in their teens and 20s, and we are broadly trusted by a lot of the population.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe main bonus of this is \u2013 something our head of commissions said a few weeks back \u2013 we don\u2019t need to panic about losing our audience, we have the opportunity to think</span> <span style=\"font-weight: 400;\">\u2018we have their attention, how should we use it?\u2019.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201c10 years ago there was a big status difference between being in TV and online news, but that has flipped 180 degrees. We have challenges with the transformation from linear to online content, but not on a level with many other public service broadcasters.</span>\r\n<h3>Decoupling funding from platforms</h3>\r\n<span style=\"font-weight: 400;\">\u201cWhat we did in NRK several years ago was to stop saying money was tied to specific platforms - now you\u2019ve got one budget for what you need to do, and you can do the thing that\u2019s best on whatever platform.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cFrom top management all the way down, we have people who understand the changes that need to be made and we are advising on things where we might have something to say.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">In terms of how they \u2018do innovation\u2019, the team is not wedded to sprints or hacks, but is the first port of call for understanding \u201cshiny new things\u201d via its risk management programme.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe started this a few years back, centrally analysing changes in technology, society and media, and contextualising early what could they mean for our mission as a public service broadcaster. \u2018What will we need to know to handle it?\u2019. \u2018Is it something we can die from?\u2019. So we don\u2019t have to handle things after they\u2019re a problem.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe have a small group where we meet frequently to discuss these insights - and we understand not just how publishing, text or filming works, but we have a larger outlook on how it will touch us at different levels of the organisation, and we have the right people to ask.\u00a0</span>\r\n\r\n[caption id=\"attachment_15320\" align=\"alignnone\" width=\"300\"]<img class=\"size-medium wp-image-15320\" src=\"https://media-innovation.news/wp-content/uploads/2020/03/Risk-Management-at-NRK-300x163.png\" alt=\"\" width=\"300\" height=\"163\" /> How NRK does innovation strategy[/caption]\r\n\r\n<span style=\"font-weight: 400;\">\u201cFrom time to time, new things happen and you have a general panic about trying to \u2018be first\u2019. We take care of understanding those changes - such as how to handle smart speakers or virtual reality - and we try to understand and contextualise those things early.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWhen the first smart speakers were launched in Norway in 2018, we had already said \u2018how can this affect us?\u2019. \u2018What will need to change for us to use this in a good way?\u2019. If they had changed the market, we\u2019d have already known it would hurt \u2018here\u2019, \u2018here\u2019 and \u2018here\u2019.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWith things like Virtual Reality or 360\u00b0 video, people were talking about how they were going to save publishing. But we said \u2018no we\u2019re not doing that anymore, we\u2019re handling those things in small projects that are cross-functional and will be killed after we understand and we\u2019ll know enough to move on\u2019.</span>\r\n<h3>From insights to R&amp;D</h3>\r\n<span style=\"font-weight: 400;\">We could assure our organisation that VR would not change us as media in the foreseeable future. </span><span style=\"font-weight: 400;\">As an organisation, this helps us focus on </span><i><span style=\"font-weight: 400;\">doing what we</span></i> <i><span style=\"font-weight: 400;\">have to do</span></i><span style=\"font-weight: 400;\">, rather than bleeding to death on a lot of useless things.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOne example of something we\u2019ve been talking about over the past two years is TikTok. It\u2019s illustrative of changes of how parts of the audience are consuming content and how users generate the content themselves, even though that\u2019s really a previous decade idea.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe ask ourselves, \u2018what parts of technological innovation do you leave to large companies instead of doing it yourselves?\u2019. The iPhone was launched 13 years ago and the media innovated a lot for smartphones in the early years. Today a lot of exploitation of more advanced features have been left to Silicon Valley and China. Having sufficient control of things like this helps us know what will really matter.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Alongside insights for risk management, some of the NRKbeta team is charged with making innovation happen internally.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe have a few people doing more hardcore R&amp;D on technology for broadcast and digital. One of our biggest successes here was a simple automatic rig built by one of my colleagues that has made it possible to cover all the microphones in a radio studio with one camera each, and so automatically make a TV programme without anyone manning cameras or editing.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cBefore, this would take a lot of people, so it helped us move resources to where they would make more difference. It also showed that we didn't always need to buy big, expensive proprietary systems for making TV. Now the NRK has started building things ourselves for a fraction of the cost. So it\u2019s changed how we worked, in moving resources, and helped us produce a lot of good TV content from things that were previously audio only.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cAnother thing, which got us international attention, was the </span><a href=\"https://www.niemanlab.org/2017/08/remember-that-norwegian-site-that-makes-readers-take-a-quiz-before-commenting-heres-an-update-on-it/\"><span style=\"font-weight: 400;\">\u2018Quiz to Comment\u2019 project</span></a><span style=\"font-weight: 400;\"> where we were testing people\u2019s understanding of a story they\u2019d read before they could comment. What it did at the time when it was released was address some deep underlying issues in many societies around disinformation in online debate.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">NRK is also credited with pioneering so-called </span><a href=\"https://en.wikipedia.org/wiki/Slow_television\"><span style=\"font-weight: 400;\">\u2018slow TV</span></a><span style=\"font-weight: 400;\">\u2019 or \u2018marathon\u2019 broadcasting projects - which this year will see them covering a five-week cycling trip with the full kit carried on bikes.</span>\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone size-medium wp-image-15321\" src=\"https://media-innovation.news/wp-content/uploads/2020/03/Screen-Shot-2020-03-09-at-11.06.19-267x300.png\" alt=\"\" width=\"267\" height=\"300\" /></span>\r\n\r\n<span style=\"font-weight: 400;\">The NRKbeta team does look outside the organisation for insights, but only so far as it needs to.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cMore and more, we\u2019re developing into something that\u2019s leveraging energy from other parts of the organisation, so we don\u2019t do everything ourselves. People come to us and say \u2018I\u2019m struggling with doing this or that\u2019. And we say \u2018maybe you should talk to that person over there?\u2019. We\u2019re not doing innovation in a small, closed group.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe do speak to our networks - at the BBC and others - and we regularly observe the cutting-edge of what people are discussing in the business. We\u2019re probably spending a lot less than many others on insight and research. One of the few things we spend money doing is going to a few conferences a year to contextualise what the media business is discussing.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cNRK did get a new remit a few years back and one of the things we were told to do was have a responsibility for media diversity in Norway. And it\u2019s ended up with us being more open to cooperation, particularly sharing all the insights from NRKbeta. We have a \u2018recent insights\u2019 talk, which is around an hour long, and last half-year we presented it around 30 times - half within NRK and half to others outside. We tell other Norwegian media everything we tell senior management at NRK.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cYou could think this has to be super secret because people will steal it - but you have to have an organisation that will act on these insights - so as long as we have this organisation, we shouldn\u2019t be worried. You\u2019re more competing against other kinds of business than media.</span>\r\n\r\n<span style=\"font-weight: 400;\">Gladly, his team\u2019s work isn\u2019t measured in a conventional sense, Hofseth explains.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe\u2019re not measured by hard measures - we\u2019re measured by what the organisation perceives that we can help them achieve. So, as long as most people in the organisation see us as a force for good, I think we\u2019re good. The important thing is that we\u2019re able to deliver, to answer most questions anyone \u2013 from the Director General to a stray journalist somewhere \u2013 might ask us.</span>\r\n<h3>The next 50 years of public service</h3>\r\n<span style=\"font-weight: 400;\">\u201cA good way to work with insight and innovation is to spend enough time analysing the insight before acting on it. An important reason we\u2019re able to do things is that we separate the thinking and the analysing, from the power structures and budgets, so we\u2019re able to think quite coldly about what things mean. We discuss not from the perspective of self-preservation, but \u2018what would it mean for our business in 50 years?\u2019 and \u2018how do we get where we want to be?\u2019.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe have been doing a lot of things for reasons we understand, so after having tried something that seemed a bit risky the first time, then repeating and doing that, and changing and moving forwards, we\u2019ve been able to shift our balance.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">And what\u2019s next for innovation at NRK, and for Hofseth\u2019s work?</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI\u2019m going to do the same thing I did last year. The insight work is a one-year cycle where we start to amass all the changes that have happened since last year. Then we chew on that. Then we\u2019ll make our presentations for people across NRK.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cI\u2019ve been doing this for 10 years - and there have only been two really big changes in that time. One is the mobile phone and particularly when the iPhone arrived in 2007 - if you go onto Wayback Machine and see 10-year-old web pages - that changed a lot. And the other is platforms and social media and those things being VC-backed, meaning they came into this with a completely different set of ethics to what we have.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cPublic service is an idea that you used to be able to get governments to build an organisation around 50 or 100 years ago, but you couldn\u2019t do that today. It\u2019s something we need to take care of. The long-term survival of public service media depends on broad public trust, love, and daily relevance.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOur purpose in this is helping the NRK adapt and stay relevant to the audience, and their needs and usage patterns through a period of massive change. So everything we do we consider within the perspective of helping secure and facilitate the public service mission of the NRK: To inform, educate, and entertain Norway.\u201d</span>\r\n\r\n&nbsp;\r\n\r\nCONTACT\r\n\r\n[caption id=\"attachment_15324\" align=\"alignnone\" width=\"300\"]<img class=\"wp-image-15324 size-medium\" src=\"https://media-innovation.news/wp-content/uploads/2020/03/Anders-Hofseth-300x200.jpg\" alt=\"\" width=\"300\" height=\"200\" /> Anders Hofseth, Photo Kim Erlandsen, NRK 2020[/caption]\r\n\r\nAnders Hofseth, journalist and strategic advisor\r\nTwitter: <a href=\"https://twitter.com/andorand\">@andorand</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"NRKbeta: public service media innovation for the 21st century","post_link":"https://media-innovation.news/media-lab/public-service-media-innovation-21st-century/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NRKbeta: public service media innovation for the 21st century\" width=\"300\" height=\"181\" src=\"https://media-innovation.news/wp-content/uploads/2020/03/NRKbeta-Venn-Diagram-300x181.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"Collaboration, insights, Public service, R&amp;D","%_edit_lock%":"1588933174:933","%_edit_last%":"933","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Bj\u00f8rnstjerne Bj\u00f8rnsons plass 1, 0340 Oslo, Norway","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Oslo","%_wpgmp_location_country%":"Norway","%_wpgmp_metabox_latitude%":"59.93551300000001","%_wpgmp_metabox_longitude%":"10.7206105","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"15325","%_wp_old_slug%":"15318","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Media labs","taxonomy=post_tag":"Collaboration, insights, Public service, R&amp;D"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15318,"infowindow_disable":false},{"source":"post","title":"HHlab: Innovating new products and business opportunities","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"HHlab: Innovating new products and business opportunities\" width=\"300\" height=\"165\" src=\"https://media-innovation.news/wp-content/uploads/2020/02/HHlab2-300x165.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">HHlab: Innovating new products and business opportunities</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The German media lab focuses on innovation at the business model level, seeking and creating products and commercial opportunities that go beyond the conventions of the news industry.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/hhlab-innovating-new-products-and-business-opportunities/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The German media lab focuses on innovation at the business model level, seeking and creating products and commercial opportunities that go beyond the conventions of the news industry.","address":"Barnerstra\u00dfe 14, 22765 Hamburg, Germany","location":{"lat":"53.5572022","city":"Hamburg","state":"Hamburg","country":"Germany","lng":"9.9318014","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/hhlab-innovating-new-products-and-business-opportunities/","zoom":2,"extra_fields":{"post_excerpt":"The German media lab focuses on innovation at the business model level, seeking and creating products and commercial opportunities that go beyond the conventions of the news industry.","post_content":"[vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1>HHlab: Innovating new products and business opportunities</h1>\r\n<em>The German media lab focuses on innovation at the business model level, seeking and creating products and commercial opportunities that go beyond the conventions of the news industry.</em>\r\n\r\nFor over a hundred years, the newspaper business was mostly a stable industry. The business model was based on readers and advertisers, and few publishers needed to think about creating commercial offerings outside these two revenue sources.\r\n\r\nBut now, the news media industry has an urgent need to rethink its business approach. As digital innovations multiply and the audience\u2019s media consumption habits change, news publishers are confronted with a vital need to create new products that suit the radically changed market.\r\n\r\nThis, in a nutshell, is the vision that drives the work of <a href=\"https://www.hhlab.de/\">HHlab</a>, the research and development unit of NOZ Medien and mh:n Medien.\r\n\r\nThe two north German regional publishers joined forces in 2016, when the former acquired the latter. Together, the companies decided to create a joint media innovation unit tasked with finding innovative commercial opportunities. Thus HHlab was born in January 2018 in Hamburg. (The \u201cHH\u201d in HHlab stands for \"Hansestadt Hamburg\", or \"Hanseatic City of Hamburg\", an abbreviation used in car registration plates in Hamburg.)\r\n<h3>Products based on digitalisation</h3>\r\nThe lab identified one such opportunity when it realised that small and medium-sized companies are often struggling to keep up with new digital tools.\r\n\r\nDigitalisation has transformed how big companies operate, but SMEs tend to lag behind with their digital transformation. Moreover, while large businesses have access to useful networks, smaller firms based outside the metropolitan areas often lack such connections.\r\n\r\nThis realisation lead HHlab to develop NETZfeld \u2013 a B2B vertical that provides both information and networking opportunities about digital transformation for small and midsize companies. Based on a subscription model, NETZfeld users get access to related news and case studies, as well as networking opportunities where they can learn from other companies. (NETZfeld will be discussed more in detail below.)\r\n\r\nAnother product idea conceived by the lab is a viral advertising agency, aiming to connect people with a strong social media presence and advertisers. Many social media influencers have a significant following but are not on the advertisers\u2019 radar. Meanwhile, some advertisers don\u2019t know how to use social media to reach a specific audience based on interest, location or demography. The viral advertising agency would help bring these two groups together.\r\n\r\nBoth product ideas have now gone through the lab\u2019s development process, and the company\u2019s management is now assessing their implementation.\r\n<h3>The road to NETZfeld</h3>\r\nIt may seem peculiar that a regional newspaper publisher would come up with products such as a B2B vertical and an advertising agency. However, the process that lead to the development of NETZfeld is a good illustration of how the lab approaches innovation projects. Joachim Dreykluft, HHlab\u2019s director, says that it started with a simple realisation.\r\n\r\n\u201cWe noticed that although there are a lot of events about digital transformation in big cities, firms based in smaller towns rarely participate in them. And even if they do, they can\u2019t always relate to conference speakers who are mostly from big companies.\u201d\r\n\r\n[caption id=\"attachment_15276\" align=\"aligncenter\" width=\"1270\"]<img class=\"wp-image-15276 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2020/02/NETZfeld.png\" alt=\"\" width=\"1270\" height=\"687\" /> NETZfeld: Digital future of rural life[/caption]\r\n\r\nThis led HHlab to develop a prototype event aimed at this specific audience. After a couple of successful test conferences, the lab realised it had to account for competition: chambers of commerce and other non-commercial actors hold similar events, and mostly for free.\r\n\r\nHHlab expanded therefore its product concept with an information component. This was possible thanks to the existing infrastructure of the local newsrooms that the two companies have in north Germany.\r\n\r\n\u201cWe approached our editors-in-chief and explained that a story about digital transformation in one location could be relevant elsewhere,\u201d Dreykluft says. This allowed the lab to add a daily feed of information into the product, which is complimented by quarterly reports and case studies.\r\n\r\n\u201cIt took almost a year for us to feel that we had the right mix of information and networking at the right price point,\u201d Dreykluft says. \u201cThe end result is basically a club. When you join NETZfeld, you buy a club membership.\u201d\r\n\r\n[caption id=\"attachment_15277\" align=\"aligncenter\" width=\"4032\"]<img class=\"wp-image-15277 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2020/02/3-The-Netzfeld-project-team-from-the-left-Soenke-Schierer-Marlene-Borchardt-Philipp-Dudek.jpg\" alt=\"\" width=\"4032\" height=\"1960\" /> The Netzfeld project team (from left): Soenke Schierer, Marlene Borchardt and Philipp Dudek[/caption]\r\n<h3>Approach to innovation</h3>\r\nHHlab has a staff of 12, half of whom are journalists. \u201cThis split is perfect,\u201d Dreykluft says. \u201cWe need the journalists\u2019 expertise, but we also need people with a customer\u2019s perspective.\u201d\r\n\r\nAs mentioned, the lab usually starts its innovation projects when someone in the team identifies a need that the market doesn\u2019t cater for, and then sketches a product concept based on this need. If the concept is convincing enough, the project is put on a \u201cfast track\u201d, which gives the project team four weeks to develop the concept further.\r\n\r\nAt this point the teams tend to consist of three people, usually a project coordinator, a topic expert and a developer. There are typically 5 or 6 active product development projects in parallel.\r\n\r\nOnce finished, the product team presents the prototype to the lab, and the whole team needs to give their buy-in in order for the concept to be developed into a full-fledged product.\r\n\r\nNot all of the explored ideas are successful, but Dreykluft emphasises that this is an important part of the process. For instance, in 2017 the lab ran a project on \u201cambient news\u201d, exploring different ways to use \u201cInternet of Things\u201d devices for journalistic content.\r\n\r\n\u201cThe conclusion was that there are indeed ways of bringing news and journalism to the Internet of Things,\u201d Dreykluft says. \u201cBut there is no Internet of Things! There is no speaker on my fridge, no screen on my oven, and my bathroom mirror is just a normal mirror.\u201d\r\n\r\nThe team thus concluded that the limited number of smart home appliances in the market, such as smart light bulbs and speakers, don\u2019t offer enough opportunities for an IoT news product. But even if the project didn\u2019t result in a marketable product, Dreykluft says such initiatives still produce learnings that are important in themselves.\r\n<h3>Focus on agility and knowledge transmission</h3>\r\nHHlab indeed values internal learning highly, and everyone in the team is expected to record and transmit their learnings. The lab uses external resources rarely for the same reason, preferring to build up its internal knowledge and competences. Team members also participate in courses on design thinking, lean startup, and innovation in the media industry at institutions such as Hyper Island and Hasso Plattner Institute.\r\n\r\n\u201cEverybody is obliged to write down everything he or she does and learns. We want to fail and learn ourselves,\u201d Dreykluft says. \u201cIf you want to learn and get better, you need two things: you need to talk within the team, and you need documentation. We document everything.\u201d\r\n\r\n[caption id=\"attachment_15278\" align=\"aligncenter\" width=\"4241\"]<img class=\"wp-image-15278 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2020/02/1-HHLab-employees-develop-a-persona-for-one-of-our-target-groups.jpg\" alt=\"\" width=\"4241\" height=\"2829\" /> HHLab team developing a persona for one of its target groups.[/caption]\r\n\r\nAs for the innovation methodologies, the lab mainly uses the design thinking process, sometimes also employing the lean start-up methodology. The important thing, whichever method is used, is agility and the ability to backtrack.\r\n\r\n\u201cYou constantly need to ask yourself if it\u2019s necessary to take a step back,\u201d Dreykluft says, adding that the team uses well-defined KPIs and data analysis to determine whether a given project is on the right track.\r\n\r\n\u201cIt really hurts when you realise that you have to go back and start again. But feeling the pain is a very good thing for learning. And you can\u2019t feel that pain from a book or a course.\u201d\r\n<h3>Spreading the innovation spirit</h3>\r\nHHlab is part of NOZ digital, a subsidiary of NOZ Medien that drives digital transformation of NOZ Medien and mh:n Medien. But when it comes to the relationship with the affiliated companies, Dreykluft admits that knowledge of the lab\u2019s work doesn\u2019t always reach other parts of the organisation.\r\n\r\nIn fact, he regularly meets people in the wider organisation who do not understand what the lab does. The innovation team is trying to address this through communication.\r\n\r\n\u201cThe workhorse of our internal communication efforts is a one-day course on Instagram storytelling,\u201d Dreykluft says. \u201cPeople come because they feel it\u2019s useful for their work. But in addition to Instagram storytelling, we also talk generally about our projects and how we work.\u201d\r\n\r\nThe lab also aims to identify people within the organisation who feel that the company should be moving faster with digital innovations, bringing them together for a six-week program. This, the lab hopes, will help the participants spread a more forward-looking mindset within the company.\r\n<h3>Links with the wider media innovation sphere</h3>\r\nAlthough connecting with the broader media innovation ecosystem is crucial, Dreykluft sees an unfortunate shortcoming with the related conferences: \u201cThe approach at these events often is, everybody should be able to join and understand the discussions. Which means that the discussions are mostly on a basic level.\u201d\r\n\r\nThis might work in terms for getting people engaged, but Dreykluft says that people working on media innovation full time would benefit from a more advanced approach. \u201cI\u2019d want to meet people who already know what agility is, or what prototyping is, or how design thinking and lean start-up methodologies differ. But the opportunities for this are rare.\u201d\r\n\r\nBeyond the media industry, HHlab has an ongoing research programme with the University of Hamburg. But when it comes to working with start-ups, Dreykluft says he is less optimistic about these collaborations than he used to be, even if Hamburg has a strong media start-up scene.\r\n\r\n\u201cI now feel that there are not so many connection points with start-ups that I thought two or three years ago, because their needs are very different from ours,\u201d he says. \u201cTheir basic need is to convince investors, so that\u2019s where they focus their energy.\u201d\r\n\r\nAlso different methods separate the two fields, as Dreykluft says that start-ups are mostly based on developing an idea, while HHlab\u2019s approach is more systematic: \u201cIn my experience, when it comes to successful product development, one of the least important things is the idea.\u201d\r\n<h3>Innovation that reduces costs</h3>\r\nAlthough the news business model served the newspaper industry well for a long time, relying on the same model for such a long time has made publishers less effective at detecting news business opportunities and creating new products, Dreykluft says. This is apparent in the way many publishers react to HHlab\u2019s work.\r\n\r\n\u201cWhat I often hear is, \u2018what you do is great but it\u2019s very expensive, and we could never afford it.\u2019 I always try to explain that actually, what we are doing is the least expensive approach you can have for successful product development.\u201d\r\n\r\nHe says that the media industry tends to create new products by taking an idea, creating a product based on it, putting it to the market \u2013 and then letting the market decide whether the product is successful or not.\r\n\r\n\u201cThat\u2019s the most expensive approach to product development there is! By contrast, our research and development methods aim to make success as likely as possible,\u201d Dreykluft says. \u201cSo in the end, we do not produce costs, we reduce them.\u201d\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"size-medium wp-image-15279 alignnone\" src=\"https://media-innovation.news/wp-content/uploads/2020/02/4-Joachim-Dreykluft-300x200.jpg\" alt=\"\" width=\"300\" height=\"200\" />\r\n\r\nJoachim Dreykluft, Director, HHlab\r\nTwitter: <a href=\"https://twitter.com/dreykluft\">@Dreykluft</a>[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"HHlab: Innovating new products and business opportunities","post_link":"https://media-innovation.news/media-lab/hhlab-innovating-new-products-and-business-opportunities/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"HHlab: Innovating new products and business opportunities\" width=\"300\" height=\"165\" src=\"https://media-innovation.news/wp-content/uploads/2020/02/HHlab2-300x165.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"","%_edit_lock%":"1611822856:931","%_edit_last%":"931","%_thumbnail_id%":"15280","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Barnerstra\u00dfe 14, 22765 Hamburg, Germany","%_wpgmp_location_city%":"Hamburg","%_wpgmp_location_state%":"Hamburg","%_wpgmp_location_country%":"Germany","%_wpgmp_metabox_latitude%":"53.5572022","%_wpgmp_metabox_longitude%":"9.9318014","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Media labs","taxonomy=post_tag":""},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15275,"infowindow_disable":false},{"source":"post","title":"VPRO Medialab: bringing storytelling to new technologies","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"VPRO Medialab: bringing storytelling to new technologies\" width=\"300\" height=\"216\" src=\"https://media-innovation.news/wp-content/uploads/2019/11/VPRO-main-image-300x216.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">VPRO Medialab: bringing storytelling to new technologies</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The Dutch broadcaster\u2019s media innovation lab uses novel technologies to provide engaging narrative experiences, while also informing its audience about the technologies\u2019 possible impact on their everyday lives.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/vpro-medialab-bringing-storytelling-to-new-technologies/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The Dutch broadcaster\u2019s media innovation lab uses novel technologies to provide engaging narrative experiences, while also informing its audience about the technologies\u2019 possible impact on their everyday lives.","address":"Hilversum, Netherlands","location":{"lat":"52.2291696","city":"Hilversum","state":"North Holland","country":"Netherlands","lng":"5.166897400000039","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/vpro-medialab-bringing-storytelling-to-new-technologies/","zoom":2,"extra_fields":{"post_excerpt":"The Dutch broadcaster\u2019s media innovation lab uses novel technologies to provide engaging narrative experiences, while also informing its audience about the technologies\u2019 possible impact on their everyday lives.","post_content":"[vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1>VPRO Medialab: bringing storytelling to new technologies</h1>\r\n<em>The Dutch broadcaster\u2019s media innovation lab uses novel technologies to provide engaging narrative experiences, while also informing its audience about the technologies\u2019 possible impact on their everyday lives.</em>\r\n\r\nWhen VPRO Medialab sets out to investigate an emerging technology, it aims to consider it from a multitude of angles. When it wanted to examine smart speakers and their storytelling potential, for instance, the project resulted in a range of outputs:\r\n<ul>\r\n \t<li>Three Black Mirror-ish short films, created by young filmmakers, that visualize possible scenarios related to smart devices.</li>\r\n \t<li>An exhibition that explored what life with omnipresent smart devices means, and how you could protect yourself from the technology.</li>\r\n \t<li>An interactive audio experience that depicted how an elderly person at the early stages of dementia could live independently thanks to smart devices.</li>\r\n</ul>\r\nGrouped together, these elements formed <a href=\"https://www.vprobroadcast.com/medialab/news/2018/Home-Smart-Home.html\">Home Smart Home</a>, a multimedia project that was nominated in the Digital Media projects category at this year\u2019s <a href=\"https://www.prixeuropa.eu/\">Prix Europa</a> awards.\r\n\r\nLike many of the projects by the Dutch broadcaster\u2019s innovation lab, Home Smart Home combined two goals: \u201cOn the one hand we want to creatively explore the possibilities that new technologies allow for storytelling,\u201d says Annelies Termeer, Creative Director of VPRO Medialab. \u201cOn the other, we aim to raise awareness of the positive and negative sides of these technologies.\u201d\r\n\r\n\u201cIn this case the project allowed our audience to reflect on what it really means when you let smart home technology enter your home.\u201d\r\n\r\n[caption id=\"attachment_15220\" align=\"alignnone\" width=\"1024\"]<a href=\"https://www.vpro.nl/medialab/projecten/overzicht/home-smart-home/home-smart-home-shorts.html\"><img class=\"wp-image-15220 size-large\" src=\"https://media-innovation.news/wp-content/uploads/2019/11/Home-smart-home-1024x576.png\" alt=\"\" width=\"1024\" height=\"576\" /></a> The Home Smart Home short films explore how smart speakers could impact our everyday life.[/caption]\r\n<h3>Legacy media on new platforms</h3>\r\nAs a public broadcaster, VPRO is at the heart of a rapidly changing media scene, with fewer and fewer people watching broadcast TV or listening to the radio. This trend is behind the mission of VPRO Medialab: as traditional media declines and audiences increasingly turn to new, digital platforms to consume media, what should the role of a public broadcaster be on these platforms?\r\n\r\nThe Netherlands has eight public broadcasters, with the <em>Nederlandse Publieke Omroep</em> (NPO) acting as a governing body. Each broadcaster has a somewhat distinct profile, with VPRO (short for <em>Vrijzinnig Protestantse Radio Omroep</em>) usually seen as the edgy and creative one, focusing on exploring borders and looking into the future, Termeer says. This makes it a natural home for an innovation lab that examines the future of media.\r\n\r\nThe lab is situated within the organisation's innovation and digital media department, and its core team consists of Termeer and one another person, a producer. When needed, however, they pull in designers, developers and project managers from elsewhere in the organisation to work on the innovation projects.\r\n\r\nThe links between the lab and the rest of the organisation are loose, which according to Termeer is both an advantage and a challenge: \u201cWe want to be useful for VPRO, but at the same time we need to make sure we have the capacity for crazy moonshot projects too, because we learn a lot from them, even if they aren\u2019t directly useful for the organisation in the near future.\u201d\r\n<h3>New tech with a practical approach</h3>\r\nWhen realizing innovation projects, Termeer says the lab takes a practical approach, following the maxim \u201clearning by doing\u201d, and always creating a final product that can be showcased to the audience. Funding for projects comes partly from NPO, partly from VPRO, and partly from external sources, depending on project.\r\n\r\nWhen choosing what technologies to work on, the lab tries to focus on areas that hold potential for novel approaches to storytelling while also raising awareness of the complexities that relate to the technology.\r\n\r\nConsider \u201cHotel Spieker\u201d, another project that examined the narrative potential of smart speakers. Presented at this year\u2019s Dutch Media Week, the cooperative game allowed players to investigate a crime that took place in a futuristic hotel. The players worked the case by listening to the recordings that smart speakers captured in different rooms of the hotel.\r\n\r\n\u201cWe wanted to let people play with the technology in a new way, but also tell a story that raises questions about privacy and data storage,\u201d says Termeer.\r\n\r\n[caption id=\"attachment_15224\" align=\"alignnone\" width=\"960\"]<img class=\"wp-image-15224 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2019/11/Hotel-Spieker.jpg\" alt=\"\" width=\"960\" height=\"519\" /> The \u201cHotel Spieker\u201d game tasked the players with solving a crime by examining audio captured by smart speakers.[/caption]\r\n\r\nMany projects make full use of the broadcaster\u2019s multimedia capabilities. VPRO\u2019s TV documentary series \u201cRobo Sapiens\u201d explored life with artificial intelligence, featuring prominently a Pepper robot as part of the programme. Online, the same concept was explored from a different point of view: users were able to participate in a version of the Turing test, called \"Bot or Not\", where they had to guess whether they were chatting with a robot or a human.\r\n\r\n\u201cThe twist was that afterwards you got to play as the bot,\u201d Termeer says. \u201cTaking this role really made you think about your perception and expectations of AI.\u201d\r\n\r\n[caption id=\"attachment_15225\" align=\"alignnone\" width=\"894\"]<img class=\"wp-image-15225 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2019/11/Robo-Sapiens.png\" alt=\"\" width=\"894\" height=\"505\" /> The \u201cRobo Sapiens\u201d documentary series had an online counterpart that put the players in the role of AI.[/caption]\r\n\r\nArtificial intelligence is likely to inspire also other projects, and Termeer says that exploring the intersection of AI and creativity is a particularly inspiring area. \u201cIf you see a piece of art, for example a painting, that you like, and are told afterwards that it was created by an AI, would it impact your reaction to it? This would be a very interesting question to examine.\u201d\r\n<h3>Broad innovation ecosystem</h3>\r\nAs mentioned, there are eight public broadcasters in the Netherlands. All of them are based in the city of Hilversum, often called \u201cmedia city\u201d, and each has its own lab or some other kind of unit dedicated to innovation projects. Moreover, there are many media festivals in the country, such as IDFA, Cinekid and STRP which offer additional opportunities for the Dutch media innovation ecosystem to come together and form connections.\r\n\r\nThis, however, also makes it important to consciously break away from the media scene and tap into the innovation efforts that are taking place in other industries, Termeer says.\r\n<blockquote>\u201cIt\u2019s crucial not to get stuck in the same bubble with other media companies. In fact, when looking for inspiration, I mostly look at what is happening in the tech, design, and art scenes, and think about how we could apply those trends.\u201d</blockquote>\r\nThis attitude extends to working with people from other fields and companies, including startups, as VPRO Medialab aims to be cross-disciplinary and open with its collaborations. \u201cIt\u2019s really on a case by case basis. We try to find the right people with the right expertise, wherever they might be.\u201d\r\n\r\n\u201cA designer or someone who builds interactive installations wouldn't necessarily think of coming to VPRO and suggest working together,\u201d Termeer says. \u201cWe want to be the entry point for these kinds of collaborations, because we think we can learn something from each other.\u201d\r\n<h3>Spreading the innovation spirit in-house</h3>\r\nFounded in 2015, it took a while for VPRO Medialab to find its feet and establish its role within the broader organisation. \u201cInitially there was an expectation for the media lab to be really innovative, but also for its projects to reach a really big audience. Along the way we\u2019ve found that those two goals don't always go together,\u201d Termeer says.\r\n\r\nIn addition to experimenting with new technologies, the unit aims to distribute its learnings to other parts of VPRO, where the ideas and results can be developed further.\r\n\r\nThe lab uses social media, intranet and monthly internal presentations to share its insights within the organisation. It also organises regular hackathons, focusing on the topics that VPRO\u2019s staff are interested in, and has used Google Design Sprint for a few projects, Termeer says. \u201cWe also try to be open for people to walk in and discuss things they\u2019re curious about.\u201d[/vc_column_text][vc_gallery images=\"15226,15231,15232,15233\"][vc_column_text]<em>Regular hackathons are one of the methods that the innovation lab uses to share its findings with the wider organisation. (Photos: David Meulenbeld, Barbara Medo, Safaa Bouzambou, Anna van Kooij)</em>\r\n\r\n&nbsp;\r\n\r\n\u201cThere are people who are keen on innovation and want to try new things. But there are also those who enjoy hearing about our projects but too often just end up going back to their daily jobs because of lack of time and resources,\u201d she says.\r\n\r\n\u201cA big issue is that other departments need to find additional resources if they want to develop our projects further. Most people are already busy with their usual duties, so that\u2019s a big obstacle.\u201d\r\n<h3>Tips for starters</h3>\r\nAs for future trends, Termeer says that augmented reality is emerging as a particularly promising field: \u201cEvery phone today has this capability, but I haven't really seen any interesting use cases in the media. AR is only being used for games, or in the commercial context. That\u2019s an opportunity I see.\u201d\r\n\r\nConsequently, the lab is now developing a smartphone interactive story that uses AR elements, <em>Dustin</em>. \u201cYou could see AR as a new public space, but one that is now being filled with Pokemons and advertising. I think there's also a role for public broadcasters, who could create more high-quality, informative AR content.\u201d\r\n\r\nFinally, as someone who has worked in the media innovation scene for many years now, does Termeer have advice for someone interested creating an innovation unit?\r\n<blockquote>\u201cIt's really important to determine what the goal of the media lab is from the start. What easily happens is that everyone has their own vision what the media lab is for. If that happens, you won\u2019t be able to please everyone.\u201d</blockquote>\r\nShe also underlines the need for structures that ensure cross-pollination of ideas within the organisation. \u201cIf for example it would be mandatory to spend one day per month with us in the media lab, it would make it part of everybody\u2019s job to engage with the lab. Otherwise, when you pull in people from other branches, it\u2019s easily seen as if you\u2019re 'stealing' people from their day jobs to do something extra.\u201d\r\n\r\nLastly, it\u2019s worth it to think about specialising on topics, rather than focusing on what everyone else is already doing. \u201cWe\u2019re trying to do this with the Dutch broadcasters. The idea is to define a focus area for each of the labs, to learn from each other, and to make sure we\u2019re not getting in each other\u2019s way.\u201d\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-15227\" src=\"https://media-innovation.news/wp-content/uploads/2019/11/unnamed-4-300x300.jpg\" alt=\"\" width=\"200\" height=\"200\" />\r\n\r\nAnnelies Termeer, Creative Director, VPRO Medialab\r\nTwitter: <a href=\"https://twitter.com/AnneliesTermeer\">@AnneliesTermeer</a>[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"VPRO Medialab: bringing storytelling to new technologies","post_link":"https://media-innovation.news/media-lab/vpro-medialab-bringing-storytelling-to-new-technologies/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"VPRO Medialab: bringing storytelling to new technologies\" width=\"300\" height=\"216\" src=\"https://media-innovation.news/wp-content/uploads/2019/11/VPRO-main-image-300x216.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"","%_edit_lock%":"1581441032:931","%_edit_last%":"931","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Hilversum, Netherlands","%_wpgmp_location_city%":"Hilversum","%_wpgmp_location_state%":"North Holland","%_wpgmp_location_country%":"Netherlands","%_wpgmp_metabox_latitude%":"52.2291696","%_wpgmp_metabox_longitude%":"5.166897400000039","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"15229","%_kleo_title_checkbox%":"1","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Media labs","taxonomy=post_tag":""},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15219,"infowindow_disable":false},{"source":"post","title":"Rad, the journalism laboratory of Radio Canada, experiments with formats for young people","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rad, the journalism laboratory of Radio Canada, experiments with formats for young people\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2019/10/rad-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Rad, the journalism laboratory of Radio Canada, experiments with formats for young people</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            In May 2016, Radio-Canada made a strong commitment to innovation by creating Rad, a journalism laboratory that develops formats for young people who get news on the Internet. Since then, the lab has come a long way: two major digital awards, a weekly YouTube news broadcast and effective collaborations with the various teams at Radio-Canada.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/rad-the-journalism-laboratory-of-radio-canada-experiments-with-formats-for-young-people/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"In May 2016, Radio-Canada made a strong commitment to innovation by creating Rad, a journalism laboratory that develops formats for young people who get news on the Internet. Since then, the lab has come a long way: two major digital awards, a weekly YouTube news broadcast and effective collaborations with the various teams at Radio-Canada.","address":"1400 Boulevard Ren\u00e9-L\u00e9vesque E, Montr\u00e9al, QC H2L 2M2, Canada","location":{"lat":"45.5175902","city":"Montr\u00e9al","state":"Qu\u00e9bec","country":"Canada","lng":"-73.55136449999998","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/rad-the-journalism-laboratory-of-radio-canada-experiments-with-formats-for-young-people/","zoom":2,"extra_fields":{"post_excerpt":"In May 2016, Radio-Canada made a strong commitment to innovation by creating Rad, a journalism laboratory that develops formats for young people who get news on the Internet. Since then, the lab has come a long way: two major digital awards, a weekly YouTube news broadcast and effective collaborations with the various teams at Radio-Canada.","post_content":"[vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1>Rad, the journalism laboratory of Radio Canada, experiments with formats for young people</h1>\r\n<em>We are republishing this article, originally published on <a href=\"https://www.meta-media.fr/2019/09/27/le-rad-le-laboratoire-de-journalisme-de-radio-canada-experimente-des-formats-pour-les-jeunes.html\">M\u00e9ta-Media</a>, as part of an editorial partnership between M\u00e9ta-Media and WAN-IFRA. The article was written by <a href=\"https://twitter.com/laure914\">Laure Delmoly</a>.</em>\r\n\r\nIn May 2016, Radio-Canada made a strong commitment to innovation by creating Rad, a journalism laboratory that develops formats for young people who get news on the Internet. The lab has achieved a lot then: two major digital awards, a weekly YouTube news broadcast and effective collaborations with the various teams at Radio-Canada.\r\n<h3>Rejuvenating the audience and renewing journalistic formats</h3>\r\nLocated on the ground floor of the Radio Canada Tower, <a href=\"https://www.rad.ca/\">Rad</a> operates in a dedicated space, separate from the rest of the editorial staff. It brings together a <strong>multidisciplinary team of 15 members</strong>: journalists, motion designers, camera operators, product managers and UX experts. Inspired by agile methods, the lab has developed a specific digital offer and renewed its audience.\r\n\r\n<em>\"We started from a simple observation: part of the population no longer listens to Radio Canada but reads our content online. How can we address this audience directly?\"</em> explains Johanne Lapierre, Editor-in-Chief.\r\n\r\nRadio Canada's editorial lab has <strong>several objectives</strong>:\r\n<ul>\r\n \t<li>renew journalistic formats</li>\r\n \t<li>develop content on social networks</li>\r\n \t<li>address the digital citizen</li>\r\n \t<li>... and a challenge: rejuvenate audiences while continuing to address its historical audience.</li>\r\n</ul>\r\nThe initiative is headed by three women: Johanne Lapierre, editor-in-chief, Gigi Huynh, digital strategist and Caroline Choini\u00e8re, digital product manager.\r\n<h3>Different formats for the same subject</h3>\r\n<em>\"We operate in broad subjects for which we offer several formats: the reader can choose the format he likes the most. They can choose their entry point into our content,\"</em> comments Johanne Lapierre.\r\n\r\nMajor topics such as <a href=\"https://www.rad.ca/dossier/controle-du-web\">control of the internet</a>, <a href=\"https://www.rad.ca/dossier/decroissance\">degrowth</a>, <a href=\"https://www.rad.ca/dossier/reproduction\">reproduction</a>, <a href=\"https://www.rad.ca/dossier/intelligence-artificielle\">artificial intelligence</a> thus generate three video formats: basic, experimentation and anticipation.\r\n<ul>\r\n \t<li><strong>Basic</strong>: an \"explainer\" format, embodied by a journalist who presents the subject to the camera with video clips and graphs. Below Marie-Eve Maheu talks about the geopolitical and economic issues related to the control of the internet.</li>\r\n</ul>\r\nhttps://www.youtube.com/watch?v=94m1xeLlLOo\r\n<ul>\r\n \t<li><strong>Experimentation</strong>: the viewer follows the journalist in the process of taking up a challenge or conducting an investigation. A \"journalism experience\" format that is popular with the younger generations.</li>\r\n</ul>\r\nBelow, Olivier Arbour-Masse, decides to try the challenge of zero waste for a month.\r\n\r\nhttps://www.youtube.com/watch?v=xXTPPrtpj4s\r\n\r\nOr Mathieu Papillon and Nicolas Pham travel around Montreal, a world-leading AI city in search of precisely... artificial intelligence.\r\n\r\nhttps://www.youtube.com/watch?v=wdqMwu_BTY8\r\n<ul>\r\n \t<li><strong>Anticipation</strong>: a decoding format consisting of interviews with experts.</li>\r\n</ul>\r\n<em>\"At Rad, we try not to settle on a format, but to experiment. Even the explainer format is rethought every time,\"</em>\u00a0adds Johanne Lapierre.\r\n\r\nThese new video formats were inspired by YouTube, and their duration ranges from five to fifteen minutes.\r\n\r\n<em>\"We don't give ourselves any time constraints. We tend to say that video viewing time is short, but it really depends on the distribution platforms. On YouTube, people can watch journalists chatting in a studio for an hour,\"</em> says Johanne Lapierre.\r\n\r\nhttps://www.youtube.com/watch?v=MO--YABw9DU\r\n<h3>An award-winning program with sustainable formats</h3>\r\n<a href=\"https://www.rad.ca/elections2018\">The \"23-23\" program</a> was set up in preparation for the provincial elections in Quebec. It won the <strong><a href=\"https://concours.infopresse.com/boomerang/resultats\">Boomerang 2018</a> award for best editorial strategy</strong>. According to the president of the Boomerang jury, Jennifer Varvaresso, this editorial production <em>\"quickly won over the jury with its relevance, creative approach and quality of execution. This format succeeds in reaching a young target group, both the well-informed and beginners, often put off by more traditional news media. All delivered with impeccable artistic direction, a pleasantly offbeat tone and an expertly thought-out digital implementation.\u201d</em>\r\n\r\n23-23 also won the <strong><a href=\"https://www.numix.ca/palmares/2019/\">Numix 2019</a> prize</strong> in the \"linear production\" category.\r\n\r\n<strong>The success of 23-23 is explained by the aim to be as close as possible to the public.</strong> Inspired by the thirty-day challenges that are all very popular online, the objective was to provide readers with 23 pieces of content at a rate of one per day in order to prepare digital citizens for an informed vote in early October 2018. Rad first surveyed its community with forty questions, gave them thirteen minutes to answer, and received 1200 responses. Inspired by the feedback, the team has developed 3 informative, accessible and attractive video formats.\r\n\r\n<strong>1. \u201cBasic\" formats on elections</strong>\r\n\r\nTake the video \"Why vote?\": a format in the style of an audition to encourage young people to vote. The auditioned people march past: comedians, theatre performers, hip-hop dancers, UQAM students in political science. The video\u00a0 addresses the lab's core target audience, the 18-39 year-olds who now represent one third of the Quebec electorate and whose abstention rate remains high.\r\n\r\nhttps://www.youtube.com/watch?v=Ctl3qSMZcHE\r\n\r\nor \"Once upon a time there were political parties\" by Nicolas Pham: a video made entirely with Playmobil toys, depicting the four Quebec political parties represented in the National Assembly.\r\n\r\nhttps://www.youtube.com/watch?v=ZuhNHCOUNIE\r\n\r\n<strong>2. \u201cQuest\" topics on the main social issues in Quebec</strong>\r\n<ul>\r\n \t<li><a href=\"https://youtu.be/TtHcFg8LSkA\">How to solve the recycling crisis in Quebec?</a></li>\r\n \t<li><a href=\"https://youtu.be/t78VK6b5WLY\">Improving the fluidity of transport</a></li>\r\n \t<li><a href=\"https://youtu.be/7PjNMCgbmFU\">Too difficult to see a shrink in Quebec?</a></li>\r\n \t<li><a href=\"https://youtu.be/n-56VFcNUj4\">Does the current school system promote inequalities?</a></li>\r\n</ul>\r\n<strong>3. A weekly news broadcast on YouTube: le bunker</strong>\r\n\r\nLe bunker is a weekly news broadcast presented by Rad journalists that covers most of the news of each week.\r\n\r\n<em>\"The format allows us to highlight the personality of our journalists. Younger generations love this authentic format. This helps to build a relationship of trust. But this more familiar tone does not allow us to cross the line into opinion. Our journalists remain rigorous in their journalistic practices,\"</em> comments Johanne Lapierre.\r\n\r\nProgram 23-23 was able to reach its audience through several distribution tools: Facebook, YouTube, Instagram, a newsletter, a chatbot and through Radio Canada sites: <a href=\"https://ici.radio-canada.ca/elections-quebec-2018\">iciradiocanada.ca</a>, <a href=\"https://curio.ca/fr/\">curio.ca</a> and <a href=\"https://www.rad.ca/\">rad.ca</a>. The programme was also advertised on radio and television.\r\n\r\nhttps://www.youtube.com/watch?v=_m-ICjjodkc\r\n\r\nThis online communication strategy has generated an organic reach of four million people, more than two million views, an average engagement rate of 9%, an average listening time of 4 minutes and 30 seconds on YouTube, and more than 15,000 subscribers to the newsletter sent out every morning. Beyond these figures, Rad's journalists attest to an online community that is very active throughout the editorial process.\r\n\r\n<em>\"Internet users thank us for the re-contextualization and analysis in their YouTube and Facebook comments,\"</em> explains Johanne Lapierre.\r\n\r\nThe format invented for Program 23-23 <a href=\"https://youtu.be/_m-ICjjodkc?list=PLdQzHRpOzSu27gCygvA2WIDltMAeqbMYT\">was renewed</a> for the October 2019 federal election: twelve minutes every Saturday since June 2019. The complete <a href=\"https://www.youtube.com/playlist?list=PLdQzHRpOzSu27gCygvA2WIDltMAeqbMYT\">playlist of the broadcasts</a> is online on the lab's YouTube account.\r\n<h3>Collaborations with TV teams and regional offices</h3>\r\nThe most creative collaboration is with the head of Quebec\u2019s provincial political office, S\u00e9bastien Bovet. For the 2018 elections, he agreed to play along and swap his tie and jacket for a Rad t-shirt and explain the so-called \u201cfirst-past-the-post\u201d electoral system in front of the camera.\r\n\r\nhttps://www.youtube.com/watch?v=ag3PdFCDny8\r\n\r\nThe Lab also collaborated with the regional offices, in particular to produce a full dossier on the <a href=\"https://www.rad.ca/dossier/francophonie\">Francophonie</a>. It was an opportunity for journalists from the Toronto, Ottawa, Moncton and Winnipeg regions to come to Montreal to receive intensive training in the new Rad scripts, and take new practices to the regions.\r\n\r\nFinally, some topics such as reports on <a href=\"https://www.rad.ca/dossier/aide-medicale-a-mourir\">medical assistance in dying</a> (legal in Quebec since four years ago) were broadcast by the TV news teams. The success of the Rad formats has also led to television broadcasts on the programming side: the best dossiers were put together to create two series that were broadcast at Christmas 2018 and in June 2019 on the <a href=\"https://ici.radio-canada.ca/rdi\">RDI</a> television channel.\r\n<h3>An agile broadcaster within Radio Canada</h3>\r\nThe Radio Canada Lab is inspired by the new methods of sprint design. <strong>The team works iteratively</strong> to improve each editorial production based on user feedback. During the subject <strong>pitch sessions</strong>, designers and developers are invited and can express themselves on editorial issues.\r\n\r\nTo infiltrate the CBC Lab and watch the team work, watch the full making-of video of the 23-23 program.\r\n\r\nhttps://www.youtube.com/watch?v=n7ctgTnCR3E\r\n\r\nListening to its community, Rad tests, learns and evolves with internet users. Rad is a renewed news experience, <strong>a mix of online styles and the journalistic rigour of Radio-Canada</strong>. <em>\"Canadians associate Radio Canada with credible journalism. Rad allows this marriage of innovation with credible journalism,\"</em> comments Johanne Lapierre.\r\n\r\nPresent on Facebook, YouTube, Instagram and Snapchat, Rad was designed to become Radio-Canada's journalistic content laboratory, and the recipe is working. We look forward to the next editorial productions from this fast-paced team.\r\n\r\n&nbsp;\r\n\r\n(Main image from <a href=\"https://www.behance.net/gallery/53664313/RAD-Strategy\">Behance</a>)[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"Rad, the journalism laboratory of Radio Canada, experiments with formats for young people","post_link":"https://media-innovation.news/media-lab/rad-the-journalism-laboratory-of-radio-canada-experiments-with-formats-for-young-people/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rad, the journalism laboratory of Radio Canada, experiments with formats for young people\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2019/10/rad-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"","%_edit_lock%":"1574762804:931","%_edit_last%":"931","%_oembed_6c00ec7340a9fec4c5122b5e2b2ecbb2%":"<iframe width=\"577\" height=\"325\" src=\"https://www.youtube.com/embed/xXTPPrtpj4s?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_6c00ec7340a9fec4c5122b5e2b2ecbb2%":"1570114620","%_oembed_d775e5ec0e7dba357b9aadfdcf137f84%":"<iframe width=\"577\" height=\"325\" src=\"https://www.youtube.com/embed/ZuhNHCOUNIE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_d775e5ec0e7dba357b9aadfdcf137f84%":"1570114620","%_oembed_d7ef632faf31374ece017aed95911261%":"<iframe width=\"577\" height=\"325\" src=\"https://www.youtube.com/embed/wdqMwu_BTY8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_d7ef632faf31374ece017aed95911261%":"1570114620","%_oembed_b2b70fbe98b69489057665cd165d4bc3%":"<iframe width=\"577\" height=\"325\" src=\"https://www.youtube.com/embed/_m-ICjjodkc?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_b2b70fbe98b69489057665cd165d4bc3%":"1570114620","%_oembed_04b1c4f54e3de2eac4a069f7fecbcaab%":"<iframe width=\"577\" height=\"325\" src=\"https://www.youtube.com/embed/ag3PdFCDny8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_80b4c1fe520397bea01c26684ce269a2%":"<iframe width=\"577\" height=\"325\" src=\"https://www.youtube.com/embed/MO--YABw9DU?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_04b1c4f54e3de2eac4a069f7fecbcaab%":"1570114620","%_oembed_time_80b4c1fe520397bea01c26684ce269a2%":"1570114620","%_oembed_bc00d081c042b4a43aa611db41521b04%":"<iframe width=\"577\" height=\"325\" src=\"https://www.youtube.com/embed/n7ctgTnCR3E?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_bc00d081c042b4a43aa611db41521b04%":"1570114621","%_oembed_7b85ffc6b17cd798a0dda7d12a14ed38%":"<iframe width=\"577\" height=\"325\" src=\"https://www.youtube.com/embed/94m1xeLlLOo?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_7b85ffc6b17cd798a0dda7d12a14ed38%":"1570114621","%_oembed_258fdc10d5bf6bdc05931ac5331d49ba%":"<iframe width=\"577\" height=\"325\" src=\"https://www.youtube.com/embed/Ctl3qSMZcHE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_258fdc10d5bf6bdc05931ac5331d49ba%":"1570114621","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"1400 Boulevard Ren\u00e9-L\u00e9vesque E, Montr\u00e9al, QC H2L 2M2, Canada","%_wpgmp_location_city%":"Montr\u00e9al","%_wpgmp_location_state%":"Qu\u00e9bec","%_wpgmp_location_country%":"Canada","%_wpgmp_metabox_latitude%":"45.5175902","%_wpgmp_metabox_longitude%":"-73.55136449999998","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_oembed_3435018c4ec3b4ca59475deaf02039e0%":"<iframe width=\"1200\" height=\"675\" src=\"https://www.youtube.com/embed/94m1xeLlLOo?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_3435018c4ec3b4ca59475deaf02039e0%":"1570114926","%_oembed_317a7724da00b5b08220cc56a37c7668%":"<iframe width=\"1200\" height=\"675\" src=\"https://www.youtube.com/embed/xXTPPrtpj4s?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_317a7724da00b5b08220cc56a37c7668%":"1570114926","%_oembed_24e5d0cf13f2b37f3f0d55c3113a5953%":"<iframe width=\"1200\" height=\"675\" src=\"https://www.youtube.com/embed/wdqMwu_BTY8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_24e5d0cf13f2b37f3f0d55c3113a5953%":"1570114926","%_oembed_6a8123f8560da994dee309d0f6f3de8a%":"<iframe width=\"1200\" height=\"675\" src=\"https://www.youtube.com/embed/MO--YABw9DU?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_6a8123f8560da994dee309d0f6f3de8a%":"1570114926","%_oembed_d632e0392347db97d0ec332f2fdbc031%":"<iframe width=\"1200\" height=\"675\" src=\"https://www.youtube.com/embed/Ctl3qSMZcHE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_d632e0392347db97d0ec332f2fdbc031%":"1570114926","%_oembed_dbd2b6a19410e06735e737ddfec82afa%":"<iframe width=\"1200\" height=\"675\" src=\"https://www.youtube.com/embed/ZuhNHCOUNIE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_dbd2b6a19410e06735e737ddfec82afa%":"1570114926","%_oembed_1c8d47c2e014818eee42cf801601cdc1%":"<iframe width=\"1200\" height=\"675\" src=\"https://www.youtube.com/embed/_m-ICjjodkc?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_1c8d47c2e014818eee42cf801601cdc1%":"1570114926","%_oembed_2ca5eee2b3ec2b91cadf3c8b946dd47d%":"<iframe width=\"1200\" height=\"675\" src=\"https://www.youtube.com/embed/ag3PdFCDny8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_2ca5eee2b3ec2b91cadf3c8b946dd47d%":"1570114926","%_oembed_e44c9393c9c5f59d06116983aeb09c36%":"<iframe width=\"1200\" height=\"675\" src=\"https://www.youtube.com/embed/n7ctgTnCR3E?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_e44c9393c9c5f59d06116983aeb09c36%":"1570114927","%_yoast_wpseo_primary_category%":"142","%_oembed_acedc5637bbeb0806ba2070f5912f48e%":"<iframe width=\"493\" height=\"277\" src=\"https://www.youtube.com/embed/xXTPPrtpj4s?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_38f65a1dbaa9098bf673759fda5cc700%":"<iframe width=\"493\" height=\"277\" src=\"https://www.youtube.com/embed/_m-ICjjodkc?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_acedc5637bbeb0806ba2070f5912f48e%":"1570114936","%_oembed_time_38f65a1dbaa9098bf673759fda5cc700%":"1570114936","%_oembed_59100399cdabd47b629099927a21fcc2%":"<iframe width=\"493\" height=\"277\" src=\"https://www.youtube.com/embed/MO--YABw9DU?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_b8fb3a6bcd0cadf81db8b78c3fbffa6c%":"<iframe width=\"493\" height=\"277\" src=\"https://www.youtube.com/embed/wdqMwu_BTY8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_59100399cdabd47b629099927a21fcc2%":"1570114936","%_oembed_time_b8fb3a6bcd0cadf81db8b78c3fbffa6c%":"1570114936","%_oembed_ab2f390635a79ba19a422d277eecc031%":"<iframe width=\"493\" height=\"277\" src=\"https://www.youtube.com/embed/94m1xeLlLOo?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_ab2f390635a79ba19a422d277eecc031%":"1570114936","%_oembed_ff5b7806bc35297534cd2365b277ed9b%":"<iframe width=\"493\" height=\"277\" src=\"https://www.youtube.com/embed/Ctl3qSMZcHE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_ff5b7806bc35297534cd2365b277ed9b%":"1570114936","%_oembed_3b9177025c9a749b578545443f816115%":"<iframe width=\"493\" height=\"277\" src=\"https://www.youtube.com/embed/ZuhNHCOUNIE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_3b9177025c9a749b578545443f816115%":"1570114936","%_oembed_712c9e77f96784ee5587b327e815c0f2%":"<iframe width=\"493\" height=\"277\" src=\"https://www.youtube.com/embed/n7ctgTnCR3E?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_712c9e77f96784ee5587b327e815c0f2%":"1570114936","%_oembed_9f40c0063d7d0927e6a24f4bb3ff5070%":"<iframe width=\"493\" height=\"277\" src=\"https://www.youtube.com/embed/ag3PdFCDny8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_9f40c0063d7d0927e6a24f4bb3ff5070%":"1570114937","%_thumbnail_id%":"15207","%_kleo_title_checkbox%":"1","%_oembed_921fca1ca667a5f7c86e3543078bcfbc%":"<iframe width=\"494\" height=\"278\" src=\"https://www.youtube.com/embed/94m1xeLlLOo?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_921fca1ca667a5f7c86e3543078bcfbc%":"1570118438","%_oembed_b620848e2b406e095b712957ace65479%":"<iframe width=\"494\" height=\"278\" src=\"https://www.youtube.com/embed/wdqMwu_BTY8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_b620848e2b406e095b712957ace65479%":"1570118441","%_oembed_b8b811e7fab00b9cce70dcb274f6c569%":"<iframe width=\"494\" height=\"278\" src=\"https://www.youtube.com/embed/ag3PdFCDny8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_2a0482c27aeba1d18cf87e3d28098b3a%":"<iframe width=\"494\" height=\"278\" src=\"https://www.youtube.com/embed/_m-ICjjodkc?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_1076ee52e4d5b823a3962da594ad983a%":"<iframe width=\"494\" height=\"278\" src=\"https://www.youtube.com/embed/n7ctgTnCR3E?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_b8b811e7fab00b9cce70dcb274f6c569%":"1570118441","%_oembed_69af302d21e74e3ece86b11b64382f04%":"<iframe width=\"494\" height=\"278\" src=\"https://www.youtube.com/embed/Ctl3qSMZcHE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_2a0482c27aeba1d18cf87e3d28098b3a%":"1570118441","%_oembed_26e668f101561310fd2b540aaca627f7%":"<iframe width=\"494\" height=\"278\" src=\"https://www.youtube.com/embed/ZuhNHCOUNIE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_1076ee52e4d5b823a3962da594ad983a%":"1570118441","%_oembed_time_69af302d21e74e3ece86b11b64382f04%":"1570118441","%_oembed_time_26e668f101561310fd2b540aaca627f7%":"1570118441","%_oembed_84c2c0062eccd1173ff6cb83319015a8%":"<iframe width=\"494\" height=\"278\" src=\"https://www.youtube.com/embed/xXTPPrtpj4s?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_a819813379f34150d51ab041c0c17404%":"<iframe width=\"494\" height=\"278\" src=\"https://www.youtube.com/embed/MO--YABw9DU?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_84c2c0062eccd1173ff6cb83319015a8%":"1570118442","%_oembed_time_a819813379f34150d51ab041c0c17404%":"1570118442","%_oembed_6f3161919fec07c1079e76b3182aa2ca%":"<iframe width=\"492\" height=\"277\" src=\"https://www.youtube.com/embed/xXTPPrtpj4s?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_6f3161919fec07c1079e76b3182aa2ca%":"1570119139","%_oembed_7d75aed9b880b3bee49bd3f7a133dc75%":"<iframe width=\"492\" height=\"277\" src=\"https://www.youtube.com/embed/94m1xeLlLOo?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_7d75aed9b880b3bee49bd3f7a133dc75%":"1570119139","%_oembed_84b20cf5a94f273a12f0ecf0b9e4a38b%":"<iframe width=\"492\" height=\"277\" src=\"https://www.youtube.com/embed/wdqMwu_BTY8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_da84598804c7fc8e3628c0ec1f923900%":"<iframe width=\"492\" height=\"277\" src=\"https://www.youtube.com/embed/MO--YABw9DU?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_da84598804c7fc8e3628c0ec1f923900%":"1570119139","%_oembed_time_84b20cf5a94f273a12f0ecf0b9e4a38b%":"1570119139","%_oembed_5bd6987743ef4f3beae6182de8f62792%":"<iframe width=\"492\" height=\"277\" src=\"https://www.youtube.com/embed/ag3PdFCDny8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_5bd6987743ef4f3beae6182de8f62792%":"1570119139","%_oembed_9a6d03a96c9bdeafde7dc2bcea825b41%":"<iframe width=\"492\" height=\"277\" src=\"https://www.youtube.com/embed/n7ctgTnCR3E?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_9a6d03a96c9bdeafde7dc2bcea825b41%":"1570119139","%_oembed_37984768d8997506e7672d7f9fdc02b6%":"<iframe width=\"492\" height=\"277\" src=\"https://www.youtube.com/embed/ZuhNHCOUNIE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_3f55cec0ac9b93cea4ff688cebb7c390%":"<iframe width=\"492\" height=\"277\" src=\"https://www.youtube.com/embed/_m-ICjjodkc?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_37984768d8997506e7672d7f9fdc02b6%":"1570119139","%_oembed_time_3f55cec0ac9b93cea4ff688cebb7c390%":"1570119139","%_oembed_05d634da8c641eac83acccf5dc1f6ec5%":"<iframe width=\"492\" height=\"277\" src=\"https://www.youtube.com/embed/Ctl3qSMZcHE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_05d634da8c641eac83acccf5dc1f6ec5%":"1570119139","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_oembed_74d3976b4d75264e38b0c0ac27499fa0%":"<iframe width=\"491\" height=\"276\" src=\"https://www.youtube.com/embed/Ctl3qSMZcHE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_74d3976b4d75264e38b0c0ac27499fa0%":"1570120286","%_oembed_b0fa19632653f69b4649f72aa9ced39c%":"<iframe width=\"491\" height=\"276\" src=\"https://www.youtube.com/embed/MO--YABw9DU?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_43cc51b2fb7dd539f285a5ba9af458b3%":"<iframe width=\"491\" height=\"276\" src=\"https://www.youtube.com/embed/n7ctgTnCR3E?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_0c4dfd43649f479b1c7152b3f2669afe%":"<iframe width=\"491\" height=\"276\" src=\"https://www.youtube.com/embed/94m1xeLlLOo?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_b0fa19632653f69b4649f72aa9ced39c%":"1570120286","%_oembed_time_43cc51b2fb7dd539f285a5ba9af458b3%":"1570120286","%_oembed_time_0c4dfd43649f479b1c7152b3f2669afe%":"1570120286","%_oembed_7b82af7dc84da0e9a1b10f2801b77390%":"<iframe width=\"491\" height=\"276\" src=\"https://www.youtube.com/embed/_m-ICjjodkc?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_c148284917a09e44429fd5b8d8c70818%":"<iframe width=\"491\" height=\"276\" src=\"https://www.youtube.com/embed/ZuhNHCOUNIE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_7b82af7dc84da0e9a1b10f2801b77390%":"1570120286","%_oembed_time_c148284917a09e44429fd5b8d8c70818%":"1570120286","%_oembed_51329646b620f60ea2b857f4c7f42a88%":"<iframe width=\"491\" height=\"276\" src=\"https://www.youtube.com/embed/xXTPPrtpj4s?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_51329646b620f60ea2b857f4c7f42a88%":"1570120286","%_oembed_05f897b3113b067426822a0cfe9d9c57%":"<iframe width=\"491\" height=\"276\" src=\"https://www.youtube.com/embed/wdqMwu_BTY8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_05f897b3113b067426822a0cfe9d9c57%":"1570120287","%_oembed_1c89f54856be0f3975f7ed7def36fad5%":"<iframe width=\"491\" height=\"276\" src=\"https://www.youtube.com/embed/ag3PdFCDny8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_1c89f54856be0f3975f7ed7def36fad5%":"1570120287","%_oembed_e335d98b6fb256367038e14150dbadae%":"<iframe title=\"Qui tente de contr\u00f4ler Internet? | Contr\u00f4le du web | Rad\" width=\"500\" height=\"281\" src=\"https://www.youtube.com/embed/94m1xeLlLOo?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_e335d98b6fb256367038e14150dbadae%":"1707422043","%_oembed_329cffc847c3bf534106c382aaad68be%":"<iframe title=\"La d\u00e9croissance \u00e0 \u00e9chelle individuelle : r\u00e9duire son empreinte carbone | D\u00e9croissance | Rad\" width=\"500\" height=\"281\" src=\"https://www.youtube.com/embed/xXTPPrtpj4s?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_329cffc847c3bf534106c382aaad68be%":"1707422043","%_oembed_80012a1f089392488d8bb91bac03f127%":"<iframe title=\"L&#039;intelligence artificielle \u00e0 Montr\u00e9al | Rad\" width=\"500\" height=\"281\" src=\"https://www.youtube.com/embed/wdqMwu_BTY8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_80012a1f089392488d8bb91bac03f127%":"1707422043","%_oembed_889c55b1ea97f3aa253111f87fd401ae%":"<iframe title=\"Se battre pour que la plan\u00e8te ne consomme plus de viande | Alimentation | Rad\" width=\"500\" height=\"281\" src=\"https://www.youtube.com/embed/MO--YABw9DU?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_889c55b1ea97f3aa253111f87fd401ae%":"1707422044","%_oembed_5965eb8920990770c10cc13734a72f7f%":"<iframe title=\"Pourquoi voter? | Programme Rad | \u00c9lections Qu\u00e9bec 2018 |  01 \u2014 23\" width=\"500\" height=\"281\" src=\"https://www.youtube.com/embed/Ctl3qSMZcHE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_5965eb8920990770c10cc13734a72f7f%":"1707422044","%_oembed_3571020df7665b3ec501e90a439cd408%":"<iframe title=\"Il \u00e9tait une fois les partis politiques... | Programme Rad | \u00c9lections Qu\u00e9bec 2018 | 03 \u2014 23\" width=\"500\" height=\"281\" src=\"https://www.youtube.com/embed/ZuhNHCOUNIE?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_3571020df7665b3ec501e90a439cd408%":"1707422044","%_oembed_f97786c9ee719916768acec6a796bc72%":"<iframe title=\"Fonds vert, Chine-Canada, tensions Iran-\u00c9tats-Unis et apartheid climatique | Bunker #01\" width=\"500\" height=\"281\" src=\"https://www.youtube.com/embed/_m-ICjjodkc?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_f97786c9ee719916768acec6a796bc72%":"1707422044","%_oembed_41f7437db93bbffa0943ddfb56b98032%":"<iframe title=\"Les \u00e9lections, comment \u00e7a fonctionne? | Programme Rad | \u00c9lections Qu\u00e9bec 2018 | 02 \u2014 23\" width=\"500\" height=\"281\" src=\"https://www.youtube.com/embed/ag3PdFCDny8?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_41f7437db93bbffa0943ddfb56b98032%":"1707422044","%_oembed_ef17c8faee3df2f6f727fa24bd929f74%":"<iframe title=\"LE CALME AVANT LES \u00c9LECTIONS | VLOGUE RAD #02\" width=\"500\" height=\"281\" src=\"https://www.youtube.com/embed/n7ctgTnCR3E?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_ef17c8faee3df2f6f727fa24bd929f74%":"1707422044","taxonomy=category":"Media labs","taxonomy=post_tag":""},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15196,"infowindow_disable":false},{"source":"post","title":"Le Tank Media: stimulator of media entrepreneurship","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Le Tank Media: stimulator of media entrepreneurship\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2019/07/1_rhiyBf6mj4VX9j2W0hcpNQ@2x-300x200.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Le Tank Media: stimulator of media entrepreneurship</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Le Tank Media has become one of the leading actors in media entrepreneurship in France. Using this experience it is now expanding its ambitions, with a 1700 m\u00b2 space dedicated to emerging media opening soon, as well as other new projects.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/le-tank-media-stimulator-of-media-entrepreneurship/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Le Tank Media has become one of the leading actors in media entrepreneurship in France. Using this experience it is now expanding its ambitions, with a 1700 m\u00b2 space dedicated to emerging media opening soon, as well as other new projects.","address":"22B Rue des Taillandiers, 75011 Paris, France","location":{"lat":"48.85519910000001","city":"Paris","state":"\u00cele-de-France","country":"France","lng":"2.3749473999999964","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/le-tank-media-stimulator-of-media-entrepreneurship/","zoom":2,"extra_fields":{"post_excerpt":"Le Tank Media has become one of the leading actors in media entrepreneurship in France. Using this experience it is now expanding its ambitions, with a 1700 m\u00b2 space dedicated to emerging media opening soon, as well as other new projects.","post_content":"[vc_row][vc_column width=\"1/4\"][/vc_column][vc_column width=\"1/2\"][vc_column_text]\r\n<h1>Le Tank Media: stimulator of media entrepreneurship</h1>\r\n<em>We are republishing this article, originally published on <a href=\"https://www.meta-media.fr/2019/07/17/le-tank-media-stimulateur-de-lentrepreneuriat-media.html\">M\u00e9ta-Media</a>, as part of an editorial partnership between M\u00e9ta-Media and WAN-IFRA. The article was written by <a href=\"https://twitter.com/alex_bouniol\">Alexandre Bouniol</a>, France T\u00e9l\u00e9visions, MediaLab.</em>\r\n\r\nStarted two years ago by <a href=\"https://twitter.com/versac\">Nicolas Vanbremeersch</a> et <a href=\"https://twitter.com/MMDP\">Mathieu Maire du Poset</a>, le Tank Media has become one of the leading actors in media entrepreneurship in France. Now the initiative is expanding its ambitions with a multitude of new projects, including a 1700 m\u00b2 space dedicated to emerging media. Interview with Mathieu Maire du Poset.\r\n<h3>An ecosystem to structure</h3>\r\nThe press is not doing well. Several large media groups have announced voluntary departure plans. The climate in the media world is, to say the least, gloomy. And yet, le Tank Media shows optimism with its slogan \u201cthe future of media is bright\u201d. According to Mathieu Maire du Poset, <strong>it is especially the big publishers that are doing badly</strong>: <em>\u201ctransforming them from inside is difficult,\u201d</em> he says. But big publishers do not represent the entire media spectrum in France. There is a <strong>real vitality in media entrepreneurship</strong>. This is one of the observations that he has made through the prism of crowdfunding, which he sees as a <em>\u201cmonitoring tool for very interesting trends and weak signals\u201d</em>. Whether we consider media professionals, entrepreneurs coming from other sectors, or enthusiasts who want to become professional, there is <strong>a strong demand</strong>.\r\n\r\nThe problem until now has been that <strong>this ecosystem <em>\u201cdoes not have a body, does not have a community\u201d</em></strong>. There is no structure within which one could share their experiences. In addition, there is a lack of competences. The founders of le Tank Media concluded that there is <em>\u201ca shortage of digital expertise. Many use digital as a support, but few as a tool to carry out real reflections on the issue\u201d</em>. This is also the case with entrepreneurial expertise: <em>\u201cmany come from the editorial side and are not trained for it\u201d</em>. Le Tank Media was born on the basis of these findings, with the intention to offer a supply to this existing demand.\r\n\r\nhttps://twitter.com/letankmedia/status/1144157829156298753\r\n<h3>An organization open to the outside</h3>\r\nTaking after the DNA of the parent company <a href=\"https://www.spintank.fr/\">Spintank</a> (\u201cwe are with those who transform the society\u201d goes the agency\u2019s slogan), le Tank Media has evolved following the same guiding lines. Mathieu Maire du Poset explains that <em>\u201cthe goal of le Tank Media is to <strong>foster the emergence of new entrepreneurship in the media, help the new media generations to grow, to structure themselves and to find the keys to profitability and independence\u201d</strong></em>. Le Tank Media is based on four pillars :\r\n<ul>\r\n \t<li><strong>Being a media</strong></li>\r\n</ul>\r\nThis allows le Tank Media to <strong>transmit <em>\u201cwhat is going on in the world of media currently</em></strong><em>, to broadcast an encouraging vision of the ecosystem, which is often said to be in a crisis but which we think is rather in a process of transformation and within which many positive things happen.\u201c</em> Le Tank Media produces content via a <a href=\"https://medium.com/letank-media\">blog</a>, a <a href=\"https://soundcloud.com/user-97945867\">podcast</a> and a newsletter.\r\n<ul>\r\n \t<li><strong>Being a community animator</strong></li>\r\n</ul>\r\nThis is a central point of le Tank Media\u2019s aim to <em>\u201ctry to <strong>bring to life this community of media entrepreneurs. Give them the possibility to meet each other, exchange, share their experiences</strong>\u2026 This is organized via monthly lunches with entrepreneurs, and annual and quarterly events.\u201d</em>\r\n<ul>\r\n \t<li><strong>A mission to connect</strong></li>\r\n</ul>\r\nBased within the coworking space of <a href=\"https://letank.fr/\">Tank</a>, le Tank Media already shares its premises with Spintank and other firms (including media). The goal is to <em><strong>\u201cmake it possible for this community to meet up on a daily basis\u201d</strong></em>. The initiative hopes to go even further with the opening <em>\u201cof a space of 1700 m\u00b2 in Paris in mid-October / early November dedicated to emerging media. There will be about 170 workstations, a studio for producing video and audio, editing stations and an event room.\u201d</em>\r\n\r\nhttps://twitter.com/letankmedia/status/1147027148571631616\r\n<ul>\r\n \t<li><strong>A task to incubate, accompany and train</strong></li>\r\n</ul>\r\nThis is the heart of le Tank Media\u2019s project, <em>\u201coffering to accompany media entrepreneurs, regardless of their stage of development. The incubation programme is for media that at some point in their lifespan need to profoundly rethink their value proposition. Whether they are publishers in the launch phase or publishers that need to reinvent themselves.\u201d</em> Twice a year, le Tank Media launches a <a href=\"http://letankmedia.fr/programmes\">call for projects</a>. On average, 35 candidatures are received, and a jury consisting of members of Tank Media and media entrepreneurs invites a third of them for an interview.\r\n\r\nSince the launch, <strong>three incubation programmes have already taken place for a total of 19 incubated media</strong>. There is no required template, but all types of media are accepted. For example during the last incubation round, a podcast, a YouTube tutorial and even magazines followed the programme (<a href=\"http://www.internetactu.net/\">Internet actu</a> and <a href=\"https://www.instagram.com/bouche_magazine/\">Bouche Magazine</a>, to take a couple of examples). For twelve weeks, the incubated companies follow trainings, meet with stakeholders, exchange with other participants and are accompanied by le Tank Media\u2019s teams. In the autumn of 2019, Mathieu Maire du Poset says that they want to go even further:\r\n\r\n<em><strong>\u201cWe will launch a first catalogue of trainings around topics of intrapreneurship and entrepreneurship. And an agency / studio that aims to accompany existing media in their capacity to develop intrapreneurship internally and launch new projects, while connecting to this ecosystem of new media in order to find more agility and resilience in their models.\u201d</strong></em>\r\n<h3>Uniting a community</h3>\r\nMathieu Maire du Poset confirms that one of le Tank Media\u2019s ambitions is <strong>uniting a community</strong>. <em>\u201cWe work a lot on the spirit of creating connections\u201d</em> among the incubated media. <strong>The old actors meet the new ones, and so on</strong>. Everything is done to facilitate exchanges between companies from all sides. This is made possible by one the great riches of incubation: <strong>diversity</strong>. The companies are all at different stages of development, coming from different backgrounds, and do not work on the same themes or media topics. <em>\u201cOne of the tasks for us is to put them in contact. They all have something to learn from each other\u201d</em>.\r\n\r\n<strong>Organising events is important to le Tank Media in helping to construct this community of media entrepreneurs</strong>. Lunches with speakers are organised every month. \u201c<a href=\"https://medium.com/letank-media/sous-l%C3%A9cume-l-%C3%A9v%C3%A9nement-qui-passe-les-m%C3%A9dias-%C3%A0-la-loupe-37d3ab8beb70\">Sous l\u2019\u00e9cume</a>\u201c (\u201cUnder the foam\u201d), a quarterly event, takes an in-depth look at a changing media trend, and \u201c<a href=\"https://www.instagram.com/bouche_magazine/\">Horizon(s)</a>\u201d, also organised quarterly, looks at professions and organisations in the media. Once a year, le Tank Media organises a meeting dedicated to getting feedback from media entrepreneurs.\r\n\r\nhttps://twitter.com/letankmedia/status/1144208121251975168\r\n\r\nThrough all these activities, the goal is to <strong>create a community of media entrepreneurs that will grow from year to year</strong>. Even if all of the individual projects will not succeed, the community will still be established. This is what Mathieu Maire du Poset underlines: <em>\u201cthere are tens and tens of people who meet, network, help each other, whom we give new ways of thinking about work, and who will apply the newly learned skills elsewhere in the sphere of emerging media\u201d</em>.\r\n\r\nParticipants will also gain skills that will be useful and valued for the sector in the medium-term. <em>\u201cIt will be a point of pride if we can say in a few years that we have fostered the birth of an ecosystem and we have helped a lot of people to work differently,\u201d</em> he adds. Contributing to the birth of this new ecosystem is also a bet on the future. <em>\u201cI think that in 10 years, the list of five largest French publishers will not necessarily be the same as today\u201d.</em>\r\n\r\n&nbsp;\r\n\r\n<em>(Main image from <a href=\"https://medium.com/letank-media/le-tank-media-un-1er-atelier-pour-lancer-la-co-construction-f9bd6e85356b\">Medium</a>)</em>[/vc_column_text][/vc_column][vc_column width=\"1/4\"][/vc_column][/vc_row]","post_title":"Le Tank Media: stimulator of media entrepreneurship","post_link":"https://media-innovation.news/media-lab/le-tank-media-stimulator-of-media-entrepreneurship/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Le Tank Media: stimulator of media entrepreneurship\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2019/07/1_rhiyBf6mj4VX9j2W0hcpNQ@2x-300x200.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"","%_edit_lock%":"1570121461:931","%_edit_last%":"931","%_oembed_46fa7353c5b0d13939f3cb445f0907eb%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_46fa7353c5b0d13939f3cb445f0907eb%":"1564595438","%_oembed_44b6d358c341716533afc333063f2976%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_44b6d358c341716533afc333063f2976%":"1564595438","%_oembed_ca2da50dc947ad1d26e28e19fd1fe09c%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_ca2da50dc947ad1d26e28e19fd1fe09c%":"1564595438","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"22B Rue des Taillandiers, 75011 Paris, France","%_wpgmp_location_city%":"Paris","%_wpgmp_location_state%":"\u00cele-de-France","%_wpgmp_location_country%":"France","%_wpgmp_metabox_latitude%":"48.85519910000001","%_wpgmp_metabox_longitude%":"2.3749473999999964","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_oembed_c9dbfd99bc7b842a4ded449a74ea487b%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_c9dbfd99bc7b842a4ded449a74ea487b%":"1570114061","%_oembed_d596f60c9220d913cb5858a8310f22ac%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_d596f60c9220d913cb5858a8310f22ac%":"1570114061","%_oembed_1ec367e96a81cd63db96a990f284e140%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_1ec367e96a81cd63db96a990f284e140%":"1570114061","%_yoast_wpseo_primary_category%":"142","%_oembed_62a8a130f30fca3a89e0b41e8ee0cf70%":"<blockquote class=\"twitter-tweet\" data-width=\"475\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_62a8a130f30fca3a89e0b41e8ee0cf70%":"1564596121","%_oembed_46e0c9206afb7f90c8ce0488b3e5e93c%":"<blockquote class=\"twitter-tweet\" data-width=\"475\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_46e0c9206afb7f90c8ce0488b3e5e93c%":"1564596121","%_oembed_40c332c826b9675bd7b73b40fb42e020%":"<blockquote class=\"twitter-tweet\" data-width=\"475\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_40c332c826b9675bd7b73b40fb42e020%":"1564596121","%_thumbnail_id%":"15192","%_kleo_title_checkbox%":"1","%_oembed_6d9ced4e16a2a93e8b32f54fffb7312a%":"<blockquote class=\"twitter-tweet\" data-width=\"477\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_6d9ced4e16a2a93e8b32f54fffb7312a%":"1564596395","%_oembed_6d459b7f121e1f4a74c532d47835fbbf%":"<blockquote class=\"twitter-tweet\" data-width=\"477\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_6d459b7f121e1f4a74c532d47835fbbf%":"1564596395","%_oembed_b76c45de2a03de34fb2052b08dbc9a07%":"<blockquote class=\"twitter-tweet\" data-width=\"477\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_b76c45de2a03de34fb2052b08dbc9a07%":"1564596395","%_oembed_1920fc504ab88ad2b3aeb4dd1214a8f0%":"<blockquote class=\"twitter-tweet\" data-width=\"476\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_4a4d25931135639c32465b45d3e1adb8%":"<blockquote class=\"twitter-tweet\" data-width=\"476\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_1920fc504ab88ad2b3aeb4dd1214a8f0%":"1564596465","%_oembed_time_4a4d25931135639c32465b45d3e1adb8%":"1564596465","%_oembed_d24a9eeb15d7fb4800364c002d4ce5ce%":"<blockquote class=\"twitter-tweet\" data-width=\"476\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_d24a9eeb15d7fb4800364c002d4ce5ce%":"1564596466","%_oembed_5166ae2734c038d12c0396911bf10770%":"<blockquote class=\"twitter-tweet\" data-width=\"473\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_5166ae2734c038d12c0396911bf10770%":"1564596671","%_oembed_8d1fe2f5eaf47b0a4b1a52c3bd5a66a3%":"<blockquote class=\"twitter-tweet\" data-width=\"473\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_8d1fe2f5eaf47b0a4b1a52c3bd5a66a3%":"1564596672","%_oembed_c4ffa3eeb6af0abf8619a4d631c28ec2%":"<blockquote class=\"twitter-tweet\" data-width=\"473\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_c4ffa3eeb6af0abf8619a4d631c28ec2%":"1564596672","%_oembed_21ef4c20118de104d2b9164dd2da93ee%":"<blockquote class=\"twitter-tweet\" data-width=\"489\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_21ef4c20118de104d2b9164dd2da93ee%":"1564652383","%_oembed_e84f4a6a7ddc2e54485c08c894559507%":"<blockquote class=\"twitter-tweet\" data-width=\"489\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_e84f4a6a7ddc2e54485c08c894559507%":"1564652383","%_oembed_d8ca6039c5578ff3fd2e7e0c6f1263b7%":"<blockquote class=\"twitter-tweet\" data-width=\"489\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_d8ca6039c5578ff3fd2e7e0c6f1263b7%":"1564652383","%_oembed_45eca71e5e2eaceef57b547885fe84d0%":"<blockquote class=\"twitter-tweet\" data-width=\"488\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_45eca71e5e2eaceef57b547885fe84d0%":"1564652535","%_oembed_a20c37a3141cf54f6606251420f3e3d0%":"<blockquote class=\"twitter-tweet\" data-width=\"488\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_a20c37a3141cf54f6606251420f3e3d0%":"1564652535","%_oembed_66f75ab26713636424a2e13be0a7d2c3%":"<blockquote class=\"twitter-tweet\" data-width=\"488\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_66f75ab26713636424a2e13be0a7d2c3%":"1564652535","%_oembed_cec55a1a28e8602076c9a86ddfc99052%":"<blockquote class=\"twitter-tweet\" data-width=\"494\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_cec55a1a28e8602076c9a86ddfc99052%":"1570114063","%_oembed_fe49f053f62b715b681707eab8c105ff%":"<blockquote class=\"twitter-tweet\" data-width=\"494\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_fe49f053f62b715b681707eab8c105ff%":"1570114063","%_oembed_6e4ec9943fe60fd3ba8c805356e49a18%":"<blockquote class=\"twitter-tweet\" data-width=\"494\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_6e4ec9943fe60fd3ba8c805356e49a18%":"1570114063","%_oembed_5f048d9f30f5863bef379d80c4a5e565%":"<blockquote class=\"twitter-tweet\" data-width=\"492\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_5f048d9f30f5863bef379d80c4a5e565%":"1570114318","%_oembed_85b0c3d8b22643b39a503013bb77575c%":"<blockquote class=\"twitter-tweet\" data-width=\"492\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_85b0c3d8b22643b39a503013bb77575c%":"1570114318","%_oembed_3adf75d477a3a64bb333743c6c7d20e1%":"<blockquote class=\"twitter-tweet\" data-width=\"492\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_3adf75d477a3a64bb333743c6c7d20e1%":"1570114318","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_oembed_d73474cafbc28eed5fe3295182408095%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">\u00ab\u00a0Au Tank media, j\u2019ai appris \u00e0 comprendre quels \u00e9taient les points forts et mes points faibles pour apprendre \u00e0 travailler de fa\u00e7on plus pragmatique.\u00a0\u00bb <a href=\"https://t.co/D4mt2BoD1w\">pic.twitter.com/D4mt2BoD1w</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144157829156298753?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_589e821f7345e4e331762c11c14b1f96%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Aujourd&#39;hui, on vous pr\u00e9sente Horizon(s), notre \u00e9v\u00e9nement pour interroger et comprendre les impacts de l\u2019innovation et du num\u00e9rique sur nos m\u00e9tiers et nos organisations. ? <a href=\"https://t.co/Q2MZuKhUyj\">https://t.co/Q2MZuKhUyj</a></p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1144208121251975168?ref_src=twsrc%5Etfw\">June 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_d73474cafbc28eed5fe3295182408095%":"1570114495","%_oembed_time_589e821f7345e4e331762c11c14b1f96%":"1570114495","%_oembed_ba2d86007e29e5e3eb6d84326ce4aa21%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">1 700m2 au c\u0153ur du 11eme \u00e0 Paris pour favoriser l\u2019\u00e9mergence d\u2019un nouvel entrepreneuriat dans les m\u00e9dias. Espace \u00e9v\u00e9nementiel, studios audio et vid\u00e9os, 170 postes de travail, 1 rooftop v\u00e9g\u00e9talis\u00e9...</p>&mdash; Le Tank media (@letankmedia) <a href=\"https://twitter.com/letankmedia/status/1147027148571631616?ref_src=twsrc%5Etfw\">July 5, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_ba2d86007e29e5e3eb6d84326ce4aa21%":"1570114495","taxonomy=category":"Media labs","taxonomy=post_tag":""},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15183,"infowindow_disable":false},{"source":"post","title":"WSJ R&#038;D: bringing data science and AI capabilities to the newsroom","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"WSJ R&#038;D: bringing data science and AI capabilities to the newsroom\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2019/06/Figure-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">WSJ R&#038;D: bringing data science and AI capabilities to the newsroom</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The Journal\u2019s R&D unit works across the newsroom to develop new computational approaches to empower journalists with machine learning and artificial intelligence resources.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/wsj-rd-bringing-data-science-and-ai-capabilities-to-the-newsroom/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The Journal\u2019s R&D unit works across the newsroom to develop new computational approaches to empower journalists with machine learning and artificial intelligence resources.","address":"New York, NY, USA","location":{"lat":"40.7127753","city":"New York","state":"New York","country":"United States","lng":"-74.0059728","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/wsj-rd-bringing-data-science-and-ai-capabilities-to-the-newsroom/","zoom":2,"extra_fields":{"post_excerpt":"The Journal\u2019s R&D unit works across the newsroom to develop new computational approaches to empower journalists with machine learning and artificial intelligence resources.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>WSJ R&amp;D: bringing data science and AI capabilities to the newsroom</h1>\r\n<em>The Journal\u2019s R&amp;D unit works across the newsroom to develop new computational approaches to empower journalists with machine learning and artificial intelligence resources. </em>\r\n\r\nThe Wall Street Journal Research &amp; Development unit was launched in March 2018. Recognizing the impact artificial intelligence will play in journalism, the WSJ R&amp;D (previously known as <a href=\"https://www.dowjones.com/press-room/wall-street-journal-appoints-francesco-marconi-rd-chief-and-head-of-media-science-lab/\">WSJ Media Science Lab</a>) is a multidisciplinary team within the Wall Street Journal specifically focused on supporting the newsroom. R&amp;D is part of the strategy group and collaborates with departments from across the Journal. Besides the full-time staff, the team hosts visiting fellows including academics, researchers and graduate students.\r\n\r\nThe output of the group includes newsgathering tools, data science driven stories and automation projects. Some recent efforts include a machine learning powered content analytics platform that analyses the Journal\u2019s archive and helps journalists find editorial insights; an online tool that <a href=\"https://www.wsj.com/articles/compare-any-two-colleges-from-the-wsj-the-college-rankings-11551886824\">automatically turns college rankings data into text</a> content and a <a href=\"https://www.wsj.com/articles/you-give-apps-sensitive-personal-information-then-they-tell-facebook-11550851636\">story using computational journalism techniques</a> to investigate Facebook\u2019s data privacy sharing practices.\r\n\r\nWSJ R&amp;D, which is comprised of data scientists, machine-learning engineers, project managers and specialized editors, is focused on deploying new technology to help transform the newsgathering. It is centred on the following key activities:\r\n<ul>\r\n \t<li>Develop AI tools to source information and story ideas through new types of data collection processes.</li>\r\n \t<li>Help journalists explore opportunities to dynamically redefine content packages at scale.</li>\r\n \t<li>Conduct research to identify technological trends that will impact the future of journalism.</li>\r\n</ul>\r\n\u201cWe build machines that help journalists find and produce powerful storytelling\u201d, summarizes Francesco Marconi, WSJ R&amp;D Chief and who is also the author of the upcoming book <a href=\"https://cup.columbia.edu/book/newsmakers/9780231191371\">Newsmakers: Artificial Intelligence and the Future of Journalism</a>.\r\n\r\nIn addition, the team develops newsroom guides for journalists including \u201c<a href=\"https://www.niemanlab.org/2019/02/acing-the-algorithmic-beat-journalisms-next-frontier/\">how to cover the algorithmic beat</a>\u201d and \u201c<a href=\"https://www.niemanlab.org/2018/11/how-the-wall-street-journal-is-preparing-its-journalists-to-detect-deepfakes/\">how to detect deepfakes</a>\u201d. Some of this research leads to broader initiatives such as the launch of the <a href=\"https://www.telegraph.co.uk/technology/2018/11/15/journalists-wall-street-journal-taught-identify-deepfakes/\">WSJ Media Forensics committee</a> -- a joint effort between the Standards &amp; Ethics team and R&amp;D to train journalists to detect AI-fuelled misinformation.\r\n<h3>A shared process: increasing internal engagement</h3>\r\nMarconi suggests that one of the strengths of the R&amp;D team is its collaborative approach and the fact of being a shared resource. \u201cWe are trying to make the process as transparent and collective as possible within WSJ. We prioritize efforts to work on based on the strategic priorities defined by the newsroom leadership.\u201d\r\n\r\nThis shared approach is connected with an internal platform for crowdsourcing ideas, which was implemented in the very beginning of the unit.\r\n\r\n\u201cWe set up an idea submission platform to give everyone an opportunity to participate in the digital transformation process. The tool is nowadays a very important source of innovation for the broader newsroom, so much so that there will be a team dedicated to manage that process.\u201c\r\n\r\n[embed]https://twitter.com/fpmarconi/status/1090610791043268609[/embed]\r\n\r\nMarconi explains that the ethos of the overall strategy department, which is led by <a href=\"https://www.dowjones.com/press-room/wall-street-journal-appoints-louise-story-editor-newsroom-strategy/\">Louise Story</a>, is collaborative and inclusive. Anyone in the newsroom can submit an idea, and on a monthly basis there\u2019s a review session open to anyone who wants to participate.\r\n\r\nBesides the crowdsourcing platform, the R&amp;D team sources new opportunities by hosting design-thinking boot camps for journalists, an activity run in close collaboration with WSJ\u2019s Training &amp; Outreach and UI/UX teams.\r\n\r\n[caption id=\"attachment_15170\" align=\"aligncenter\" width=\"1024\"]<img class=\"wp-image-15170 size-large\" src=\"https://media-innovation.news/wp-content/uploads/2019/06/Figure2-1024x768.jpg\" alt=\"\" width=\"1024\" height=\"768\" /> Journalists at the Wall Street Journal participate in design thinking exercises to identify and systematize new opportunities for the newsroom. Image credit: WSJ[/caption]\r\n<h3>Prioritization principles: innovation connected with OKRs</h3>\r\nRelying much on processes, this is a results-oriented unit. Every project is connected with broader strategic goals, which include diversifying and growing new audience, as well as differentiating WSJ\u2019s journalism.\r\n\r\n\u201cWe are not doing things just for the sake of experimentation. Everything we work on must be tied to a measurable outcome and, most importantly, have real newsroom impact. For every project we define OKRs (objectives and key results), a process that <a href=\"https://medium.com/dowjones/how-the-wsj-ios-team-promotes-cross-team-collaboration-through-okr-driven-feature-requests-a3f534bcccb\">was introduced by our colleagues in the PDE</a> (product, design and engineering) team\u201d.\r\n\r\nWhen defining the scope of new R&amp;D undertakings, the team goes through a vetting and planning process to ensure projects satisfy the following guiding principles:\r\n<ol>\r\n \t<li>Newsroom impact: no unstructured experiments, every project must have a specific use case and outcome.</li>\r\n \t<li>Collaboration degree: it should support editors and reporters across multiple departments.</li>\r\n \t<li>Scalability: smart resource allocation, avoiding one-off projects.</li>\r\n \t<li>Impact on newsgathering or production: the team\u2019s goal is to help establish emerging journalistic processes, as opposed to new product development (an effort led by a different team).</li>\r\n \t<li>Deployment of Artificial intelligence (AI) and/or machine learning (ML): those are considered the transformational capabilities necessary for the modern newsroom by the R&amp;D unit</li>\r\n</ol>\r\n<h3>R&amp;D in relation to the WSJ</h3>\r\nR&amp;D is designed to align with the overall strategy of the newsroom, and cooperation with other teams within the organization is therefore important and very much desired. One example is the data infrastructure provided by Dow Jones (WSJ\u2019s parent company), which the group relies on in order to scale its projects.\r\n\r\n\u201cSomething unique about developing AI capabilities at the Wall Street Journal is the support and guidance we receive from Dow Jones which has a fantastic technology team, as well as vast <a href=\"https://medium.com/dowjones/how-dow-jones-dna-powers-data-scientists-with-the-tools-they-need-to-succeed-8bf27b887672\">data science capabilities</a> we can leverage.\u201d\r\n\r\nBesides teaming up with internal stakeholders, R&amp;D also engages with universities and technology companies for select projects. For example, in collaboration with the Craig Newmark Graduate School of Journalism, the team tested an emerging newsgathering approach. They leveraged an AI-powered reporting device developed by <a href=\"https://www.cortico.ai/\">Cortico</a>, a \u201cdigital hearth\u201d that dynamically records and structures interviews as the journalist guides subjects through questions about locally relevant topics.\r\n\r\n[caption id=\"attachment_15171\" align=\"aligncenter\" width=\"1024\"]<img class=\"wp-image-15171 size-large\" src=\"https://media-innovation.news/wp-content/uploads/2019/06/Figure3-1024x768.jpg\" alt=\"\" width=\"1024\" height=\"768\" /> Participants at WSJ event engage with a \"digital hearth\" developed by Cortico. The AI-powered device ingests audio responses and structures content to help journalists find editorial insights. Image credit: WSJ[/caption]\r\n\r\nAs for future goals, Marconi explains that R&amp;D\u2019s ambition is to help democratize data science and AI practices throughout the newsroom while building on core journalistic skills and talents.\r\n\r\n\u201cThese smart tools can augment the work of our talented journalists, but they can\u2019t replicate their journalistic instinct. Although technology is increasingly impactful in the modern media landscape, the editorial process will always be driven by humans,\u201d Marconi said.\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone size-medium wp-image-15164\" style=\"font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen-Sans, Ubuntu, Cantarell, 'Helvetica Neue', sans-serif;\" src=\"https://media-innovation.news/wp-content/uploads/2019/06/Francesco-Marconi-300x169.png\" alt=\"\" width=\"300\" height=\"169\" />\r\n\r\nFrancesco Marconi, WSJ R&amp;D Chief\r\n\r\nTwitter: <a href=\"https://twitter.com/fpmarconi?lang=en-\">@fpmarconi</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"WSJ R&#038;D: bringing data science and AI capabilities to the newsroom","post_link":"https://media-innovation.news/media-lab/wsj-rd-bringing-data-science-and-ai-capabilities-to-the-newsroom/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"WSJ R&#038;D: bringing data science and AI capabilities to the newsroom\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2019/06/Figure-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"","%_edit_lock%":"1581439670:931","%_oembed_43b450e1d2c00db2c09f384bc43f2e09%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"en\" dir=\"ltr\">.<a href=\"https://twitter.com/WSJ?ref_src=twsrc%5Etfw\">@WSJ</a> is decentralizing innovation by inviting our journalists to participate in the process! We launched an internal platform where staff can submit new ideas which are then reviewed by a cross functional group and later evaluated according to a set of strategic criteria? <a href=\"https://t.co/5jxA32C1HF\">pic.twitter.com/5jxA32C1HF</a></p>&mdash; Francesco Marconi (@fpmarconi) <a href=\"https://twitter.com/fpmarconi/status/1090610791043268609?ref_src=twsrc%5Etfw\">January 30, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_43b450e1d2c00db2c09f384bc43f2e09%":"1561552435","%_edit_last%":"931","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"New York, NY, USA","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"40.7127753","%_wpgmp_metabox_longitude%":"-74.0059728","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_oembed_d0806a8a801f4b23ea8193a429cfee43%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"en\" dir=\"ltr\">.<a href=\"https://twitter.com/WSJ?ref_src=twsrc%5Etfw\">@WSJ</a> is decentralizing innovation by inviting our journalists to participate in the process! We launched an internal platform where staff can submit new ideas which are then reviewed by a cross functional group and later evaluated according to a set of strategic criteria? <a href=\"https://t.co/5jxA32C1HF\">pic.twitter.com/5jxA32C1HF</a></p>&mdash; Francesco Marconi (@fpmarconi) <a href=\"https://twitter.com/fpmarconi/status/1090610791043268609?ref_src=twsrc%5Etfw\">January 30, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_d0806a8a801f4b23ea8193a429cfee43%":"1575033438","%_yoast_wpseo_primary_category%":"142","%_oembed_0a77ba97cc52b3bbb39b22af40d2e999%":"<blockquote class=\"twitter-tweet\" data-width=\"477\" data-dnt=\"true\"><p lang=\"en\" dir=\"ltr\">.<a href=\"https://twitter.com/WSJ?ref_src=twsrc%5Etfw\">@WSJ</a> is decentralizing innovation by inviting our journalists to participate in the process! We launched an internal platform where staff can submit new ideas which are then reviewed by a cross functional group and later evaluated according to a set of strategic criteria? <a href=\"https://t.co/5jxA32C1HF\">pic.twitter.com/5jxA32C1HF</a></p>&mdash; Francesco Marconi (@fpmarconi) <a href=\"https://twitter.com/fpmarconi/status/1090610791043268609?ref_src=twsrc%5Etfw\">January 30, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_0a77ba97cc52b3bbb39b22af40d2e999%":"1561552479","%_thumbnail_id%":"15169","%_oembed_8282ca96b4f6856a2f43c171c414189c%":"<blockquote class=\"twitter-tweet\" data-width=\"482\" data-dnt=\"true\"><p lang=\"en\" dir=\"ltr\">.<a href=\"https://twitter.com/WSJ?ref_src=twsrc%5Etfw\">@WSJ</a> is decentralizing innovation by inviting our journalists to participate in the process! We launched an internal platform where staff can submit new ideas which are then reviewed by a cross functional group and later evaluated according to a set of strategic criteria? <a href=\"https://t.co/5jxA32C1HF\">pic.twitter.com/5jxA32C1HF</a></p>&mdash; Francesco Marconi (@fpmarconi) <a href=\"https://twitter.com/fpmarconi/status/1090610791043268609?ref_src=twsrc%5Etfw\">January 30, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_8282ca96b4f6856a2f43c171c414189c%":"1561552753","%_oembed_a1e3dd4c4acb4c2e5fe3d78c579ee266%":"<blockquote class=\"twitter-tweet\" data-width=\"472\" data-dnt=\"true\"><p lang=\"en\" dir=\"ltr\">.<a href=\"https://twitter.com/WSJ?ref_src=twsrc%5Etfw\">@WSJ</a> is decentralizing innovation by inviting our journalists to participate in the process! We launched an internal platform where staff can submit new ideas which are then reviewed by a cross functional group and later evaluated according to a set of strategic criteria? <a href=\"https://t.co/5jxA32C1HF\">pic.twitter.com/5jxA32C1HF</a></p>&mdash; Francesco Marconi (@fpmarconi) <a href=\"https://twitter.com/fpmarconi/status/1090610791043268609?ref_src=twsrc%5Etfw\">January 30, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_a1e3dd4c4acb4c2e5fe3d78c579ee266%":"1562314805","%_oembed_d5706e6336dd0b728903dd708a3cd1a6%":"<blockquote class=\"twitter-tweet\" data-width=\"475\" data-dnt=\"true\"><p lang=\"en\" dir=\"ltr\">.<a href=\"https://twitter.com/WSJ?ref_src=twsrc%5Etfw\">@WSJ</a> is decentralizing innovation by inviting our journalists to participate in the process! We launched an internal platform where staff can submit new ideas which are then reviewed by a cross functional group and later evaluated according to a set of strategic criteria? <a href=\"https://t.co/5jxA32C1HF\">pic.twitter.com/5jxA32C1HF</a></p>&mdash; Francesco Marconi (@fpmarconi) <a href=\"https://twitter.com/fpmarconi/status/1090610791043268609?ref_src=twsrc%5Etfw\">January 30, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_d5706e6336dd0b728903dd708a3cd1a6%":"1562315063","%_oembed_a211df57b2d0e88095b5dc573a079d4b%":"<blockquote class=\"twitter-tweet\" data-width=\"473\" data-dnt=\"true\"><p lang=\"en\" dir=\"ltr\">.<a href=\"https://twitter.com/WSJ?ref_src=twsrc%5Etfw\">@WSJ</a> is decentralizing innovation by inviting our journalists to participate in the process! We launched an internal platform where staff can submit new ideas which are then reviewed by a cross functional group and later evaluated according to a set of strategic criteria? <a href=\"https://t.co/5jxA32C1HF\">pic.twitter.com/5jxA32C1HF</a></p>&mdash; Francesco Marconi (@fpmarconi) <a href=\"https://twitter.com/fpmarconi/status/1090610791043268609?ref_src=twsrc%5Etfw\">January 30, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_a211df57b2d0e88095b5dc573a079d4b%":"1562315103","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_oembed_11f8db547bc8cae02166dd4f8ca3aab5%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"en\" dir=\"ltr\">.<a href=\"https://twitter.com/WSJ?ref_src=twsrc%5Etfw\">@WSJ</a> is decentralizing innovation by inviting our journalists to participate in the process! We launched an internal platform where staff can submit new ideas which are then reviewed by a cross functional group and later evaluated according to a set of strategic criteria? <a href=\"https://t.co/5jxA32C1HF\">pic.twitter.com/5jxA32C1HF</a></p>&mdash; Francesco Marconi (@fpmarconi) <a href=\"https://twitter.com/fpmarconi/status/1090610791043268609?ref_src=twsrc%5Etfw\">January 30, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_11f8db547bc8cae02166dd4f8ca3aab5%":"1575033441","%_oembed_a50c65d72781f316d891ce6f4b6a5425%":"<blockquote class=\"twitter-tweet\" data-width=\"512\" data-dnt=\"true\"><p lang=\"en\" dir=\"ltr\">.<a href=\"https://twitter.com/WSJ?ref_src=twsrc%5Etfw\">@WSJ</a> is decentralizing innovation by inviting our journalists to participate in the process! We launched an internal platform where staff can submit new ideas which are then reviewed by a cross functional group and later evaluated according to a set of strategic criteria? <a href=\"https://t.co/5jxA32C1HF\">pic.twitter.com/5jxA32C1HF</a></p>&mdash; Francesco Marconi (@fpmarconi) <a href=\"https://twitter.com/fpmarconi/status/1090610791043268609?ref_src=twsrc%5Etfw\">January 30, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_a50c65d72781f316d891ce6f4b6a5425%":"1581439807","taxonomy=category":"Media labs","taxonomy=post_tag":""},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15167,"infowindow_disable":false},{"source":"post","title":"La Compagnie Rotative, innovation through proximity","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"La Compagnie Rotative, innovation through proximity\" width=\"300\" height=\"157\" src=\"https://media-innovation.news/wp-content/uploads/2019/04/open-graph-300x157.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">La Compagnie Rotative, innovation through proximity</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            \u201cLa Compagnie Rotative is the media lab of proximities.\u201d This phrase summarises well the philosophy behind the media lab of the group Centre France. Its approach to innovation is based on closeness between people, local economic actors, and citizens, as well as sharing and creating connections.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/la-compagnie-rotative-innovation-through-proximity/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"\u201cLa Compagnie Rotative is the media lab of proximities.\u201d This phrase summarises well the philosophy behind the media lab of the group Centre France. Its approach to innovation is based on closeness between people, local economic actors, and citizens, as well as sharing and creating connections.","address":"Clermont-Ferrand, France","location":{"lat":"45.77722199999999","city":"Clermont-Ferrand","state":"Auvergne-Rh\u00f4ne-Alpes","country":"France","lng":"3.0870250000000397","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/la-compagnie-rotative-innovation-through-proximity/","zoom":2,"extra_fields":{"post_excerpt":"\u201cLa Compagnie Rotative is the media lab of proximities.\u201d This phrase summarises well the philosophy behind the media lab of the group Centre France. Its approach to innovation is based on closeness between people, local economic actors, and citizens, as well as sharing and creating connections.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>La Compagnie Rotative, innovation through proximity</h1>\r\n<em>We are republishing this article, originally published on <a href=\"https://www.meta-media.fr/2019/04/17/la-compagnie-rotative-linnovation-par-la-proximite.html\">M\u00e9ta-Media</a>, as part of an editorial partnership between M\u00e9ta-Media and WAN-IFRA. The article was written by <a href=\"https://twitter.com/alex_bouniol\">Alexandre Bouniol</a>, France T\u00e9l\u00e9visions, MediaLab.</em>\r\n\r\n\u201cLa Compagnie Rotative is the media lab of proximities.\u201d This phrase summarises well the philosophy behind the media lab of the group <a href=\"https://www.centrefrance.com/\">Centre France</a>. Its approach to innovation is based on closeness between people, local economic actors, and citizens, as well as sharing and creating connections. Read on for an interview with <a href=\"https://twitter.com/rapou?lang=fr\">Rapha\u00ebl Poughon</a>, cofounder of la <a href=\"https://www.compagnie-rotative.fr/mecaniques/\">Compagnie Rotative</a>.\r\n<h3>People before machines</h3>\r\nCreated five years ago in 2014, the media lab of Centre France changed its name last January to become La Compagnie Rotative. Since its conception, the vision for this new operation has been clear: promoting innovation within the group.\r\n\r\n<strong>It was agreed from the outset that the lab should not only focus on new technologies, but rather be a part of a comprehensive transformation of the group overall.</strong>\r\n<blockquote>\u201cDigital transformation was one of the levers. We worked a lot on internal communications, workflows, and so on. Generally the approach was more cultural than digital\u201d, explains Rapha\u00ebl Poughon.</blockquote>\r\nhttps://youtu.be/D9FkMjxF-os\r\n\r\nSeveral tools were developed within the group by Rapha\u00ebl Poughon and <a href=\"https://twitter.com/quentinjaud\">Quentin Jaud</a>, who lead la Compagnie Rotative:\r\n<ul>\r\n \t<li><strong>Setting up an internal social network.</strong> Built together with the group\u2019s collaborators, the tool serves as the cornerstone in the group\u2019s transformation. The guiding idea of its development is based on <em>design thinking</em>; in other words, the goal is to design a tool that is most in line with its users\u2019 needs and that allows for agile development over time. Rapha\u00ebl Poughon even describes it as a \u201cTroyan horse of transformation\u201d, since the tool has resulted in \u201cblowing up the silos between department\u201d, \u201chighlighting competencies\u201d of the staff, and \u201cdiscovering new management methods\u201d.</li>\r\n \t<li><strong>Organising internal events</strong>, such as \u201cMorning Labs\u201d, which bring together several collaborators from various departments to discuss the logic of innovation around breakfast. Also meetings with managers are organised to discuss \u201cdigital trends\u201d, and especially to share technological watch insights.</li>\r\n</ul>\r\nAccording to Rapha\u00ebl Poughon, the user-centered approach is part of the aim to \u201cintegrate the collaborators in this dynamic, and not to impose strategies that are conceived in a very vertical manner\u201d.\r\n<h3>Opportunity to promote innovation through proximity</h3>\r\nThe initial purpose of the media lab was to resolutely turn towards internal problematics. <strong>But very soon, Rapha\u00ebl Poughon saw that \u201cto work on transformation and innovation, we needed to open to the outside\u201d.</strong>\r\n\r\nConsequently, the lab of Centre France has started to collaborate with external actors more and more. \u201cInitially with other media, then with other industries\u201d. That is the reason why the media lab changed its name to la Compagnie Rotative. What has remained is the vision of \u201ccreating links and bringing trust locally\u201d.\r\n\r\nThese new types of collaborations take various forms:\r\n<ul>\r\n \t<li><strong>Meetings with citizens.</strong> The Lab organises meetings called \u201cRendez-vous de la Montagne\u201d (after one of the group\u2019s titles), which are ateliers where citizens and journalists meet \u201cat the same level\u201d to recreate a connection between them.</li>\r\n</ul>\r\nhttps://twitter.com/LaCieRotative/status/1103384310600687616\r\n<ul>\r\n \t<li><strong>Collaboration with journalists from other publishers.</strong> A \u201cJourno Camp\u201d was organised last year by the media lab to bring together data journalists from all over France. It resulted in the birth of the collective \u201c<a href=\"https://collectif-datalocal.github.io/\">data+local</a>\u201d, \u201cwhich allows for exchange of best practices, capacities, tools, mistakes and databases\u201d, and to \u201cpush for open data\u201d among database owners.</li>\r\n</ul>\r\n<img class=\"wp-image-15142 size-full aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2019/04/Capture-d\u2019e\u0301cran-2019-04-09-a\u0300-12.51.08-600x550.png\" alt=\"\" width=\"600\" height=\"550\" />\r\n<ul>\r\n \t<li><strong>Collaboration with local businesses to promote open innovation.</strong> La Compagnie Rotative organises several events, such as a hackathon last year on the topic of \u201cnew proximities\u201d.</li>\r\n \t<li><strong>Startup incubation.</strong> This programme was launched last year to promote startups \u201cin services, locality and utility\u201d, and to \u201cincrease the competencies and skills\u201d in an innovative setting. Since <strong>\u201cthe entrepreneurial ecosystem has a way of doing and seeing things that we don\u2019t, and that don\u2019t exist in our culture, it\u2019s a good way for these two worlds to exchange and learn from each other.\u201d</strong> Five startups were selected at the end of the programme. The goal is not necessarily to integrate these startups in the group, but to allow them to grow and exchange know-how and skills. A concrete example is the mentorship between the companies and (voluntary) mentors from the group Centre-France. This allows the mentors to put their competencies to work in a new setting, while the companies in turn benefit from their expertise.</li>\r\n \t<li><strong>Structuring a network of local startups.</strong> The Compagnie Rotative has launched a collective \u2013 <a href=\"https://startup-festival.com/\">Magma</a> \u2013 that gathers together four incubators. The first event took place 1 April 2019, bringing together 40 startups.</li>\r\n</ul>\r\n<img class=\"wp-image-15143 size-full aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2019/04/Capture-d\u2019e\u0301cran-2019-04-09-a\u0300-12.53.26-600x244.png\" alt=\"\" width=\"600\" height=\"244\" />\r\n\r\nConcerning the next steps, Rapha\u00ebl Poughon plans to \u201cpromote openness in our ecosystem and especially the ability to mobilise even more the citizen side of the media lab\u201d, and to open up more to \u201cresearchers and schools\u201d to compliment their research.[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"La Compagnie Rotative, innovation through proximity","post_link":"https://media-innovation.news/media-lab/la-compagnie-rotative-innovation-through-proximity/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"La Compagnie Rotative, innovation through proximity\" width=\"300\" height=\"157\" src=\"https://media-innovation.news/wp-content/uploads/2019/04/open-graph-300x157.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"","%_edit_lock%":"1561556589:931","%_edit_last%":"931","%_oembed_a3f26a635deace1e78376a571730c68c%":"<iframe width=\"592\" height=\"444\" src=\"https://www.youtube.com/embed/D9FkMjxF-os?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_a3f26a635deace1e78376a571730c68c%":"1556209650","%_oembed_4288c0735f85407a5203e5a1fd65cda0%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Ravis d\u2019avoir facilit\u00e9 une belle soir\u00e9e d\u2019intelligence collective sur le th\u00e8me de la mobilit\u00e9 pr les <a href=\"https://twitter.com/hashtag/rdvLaMontagne?src=hash&amp;ref_src=twsrc%5Etfw\">#rdvLaMontagne</a> avec les clermontois ! <a href=\"https://twitter.com/hashtag/proximit%C3%A9?src=hash&amp;ref_src=twsrc%5Etfw\">#proximit\u00e9</a> <a href=\"https://t.co/VDTl379CZ8\">pic.twitter.com/VDTl379CZ8</a></p>&mdash; La Compagnie Rotative (@LaCieRotative) <a href=\"https://twitter.com/LaCieRotative/status/1103384310600687616?ref_src=twsrc%5Etfw\">March 6, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_4288c0735f85407a5203e5a1fd65cda0%":"1556209791","%_thumbnail_id%":"15156","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Clermont-Ferrand, France","%_wpgmp_location_city%":"Clermont-Ferrand","%_wpgmp_location_state%":"Auvergne-Rh\u00f4ne-Alpes","%_wpgmp_location_country%":"France","%_wpgmp_metabox_latitude%":"45.77722199999999","%_wpgmp_metabox_longitude%":"3.0870250000000397","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_oembed_c5decef50b7379658e6a866760be7c3a%":"<iframe width=\"1200\" height=\"900\" src=\"https://www.youtube.com/embed/D9FkMjxF-os?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_c5decef50b7379658e6a866760be7c3a%":"1556210005","%_oembed_457a99338a024290ec1af3b5bffc0273%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Ravis d\u2019avoir facilit\u00e9 une belle soir\u00e9e d\u2019intelligence collective sur le th\u00e8me de la mobilit\u00e9 pr les <a href=\"https://twitter.com/hashtag/rdvLaMontagne?src=hash&amp;ref_src=twsrc%5Etfw\">#rdvLaMontagne</a> avec les clermontois ! <a href=\"https://twitter.com/hashtag/proximit%C3%A9?src=hash&amp;ref_src=twsrc%5Etfw\">#proximit\u00e9</a> <a href=\"https://t.co/VDTl379CZ8\">pic.twitter.com/VDTl379CZ8</a></p>&mdash; La Compagnie Rotative (@LaCieRotative) <a href=\"https://twitter.com/LaCieRotative/status/1103384310600687616?ref_src=twsrc%5Etfw\">March 6, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_457a99338a024290ec1af3b5bffc0273%":"1556210005","%_yoast_wpseo_primary_category%":"142","%_oembed_a052055b73975de111471d878728a2e5%":"<blockquote class=\"twitter-tweet\" data-width=\"475\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Ravis d\u2019avoir facilit\u00e9 une belle soir\u00e9e d\u2019intelligence collective sur le th\u00e8me de la mobilit\u00e9 pr les <a href=\"https://twitter.com/hashtag/rdvLaMontagne?src=hash&amp;ref_src=twsrc%5Etfw\">#rdvLaMontagne</a> avec les clermontois ! <a href=\"https://twitter.com/hashtag/proximit%C3%A9?src=hash&amp;ref_src=twsrc%5Etfw\">#proximit\u00e9</a> <a href=\"https://t.co/VDTl379CZ8\">pic.twitter.com/VDTl379CZ8</a></p>&mdash; La Compagnie Rotative (@LaCieRotative) <a href=\"https://twitter.com/LaCieRotative/status/1103384310600687616?ref_src=twsrc%5Etfw\">March 6, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_a052055b73975de111471d878728a2e5%":"1556210014","%_oembed_b1ea92f7f426f88837829e87cacfe13e%":"<iframe width=\"475\" height=\"356\" src=\"https://www.youtube.com/embed/D9FkMjxF-os?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_b1ea92f7f426f88837829e87cacfe13e%":"1556210014","%_kleo_title_checkbox%":"1","%_wp_old_date%":"2019-04-25","%_oembed_e7fae957b4d0cd3b00432334e9c16af3%":"<blockquote class=\"twitter-tweet\" data-width=\"478\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Ravis d\u2019avoir facilit\u00e9 une belle soir\u00e9e d\u2019intelligence collective sur le th\u00e8me de la mobilit\u00e9 pr les <a href=\"https://twitter.com/hashtag/rdvLaMontagne?src=hash&amp;ref_src=twsrc%5Etfw\">#rdvLaMontagne</a> avec les clermontois ! <a href=\"https://twitter.com/hashtag/proximit%C3%A9?src=hash&amp;ref_src=twsrc%5Etfw\">#proximit\u00e9</a> <a href=\"https://t.co/VDTl379CZ8\">pic.twitter.com/VDTl379CZ8</a></p>&mdash; La Compagnie Rotative (@LaCieRotative) <a href=\"https://twitter.com/LaCieRotative/status/1103384310600687616?ref_src=twsrc%5Etfw\">March 6, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_e7fae957b4d0cd3b00432334e9c16af3%":"1556266380","%_oembed_cdb2afafb35abc159de2c31f9d3c9f6f%":"<iframe width=\"478\" height=\"359\" src=\"https://www.youtube.com/embed/D9FkMjxF-os?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_cdb2afafb35abc159de2c31f9d3c9f6f%":"1556266380","%_oembed_41d64e9167e271948923ffeb47ccf8fb%":"<blockquote class=\"twitter-tweet\" data-width=\"477\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Ravis d\u2019avoir facilit\u00e9 une belle soir\u00e9e d\u2019intelligence collective sur le th\u00e8me de la mobilit\u00e9 pr les <a href=\"https://twitter.com/hashtag/rdvLaMontagne?src=hash&amp;ref_src=twsrc%5Etfw\">#rdvLaMontagne</a> avec les clermontois ! <a href=\"https://twitter.com/hashtag/proximit%C3%A9?src=hash&amp;ref_src=twsrc%5Etfw\">#proximit\u00e9</a> <a href=\"https://t.co/VDTl379CZ8\">pic.twitter.com/VDTl379CZ8</a></p>&mdash; La Compagnie Rotative (@LaCieRotative) <a href=\"https://twitter.com/LaCieRotative/status/1103384310600687616?ref_src=twsrc%5Etfw\">March 6, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_41d64e9167e271948923ffeb47ccf8fb%":"1556266631","%_oembed_8850e6ab0f5bd305b95cbcd50e2cbdab%":"<iframe width=\"477\" height=\"358\" src=\"https://www.youtube.com/embed/D9FkMjxF-os?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_8850e6ab0f5bd305b95cbcd50e2cbdab%":"1556266631","%_oembed_d33488cc31010b3769311546b90fc0c3%":"<blockquote class=\"twitter-tweet\" data-width=\"481\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Ravis d\u2019avoir facilit\u00e9 une belle soir\u00e9e d\u2019intelligence collective sur le th\u00e8me de la mobilit\u00e9 pr les <a href=\"https://twitter.com/hashtag/rdvLaMontagne?src=hash&amp;ref_src=twsrc%5Etfw\">#rdvLaMontagne</a> avec les clermontois ! <a href=\"https://twitter.com/hashtag/proximit%C3%A9?src=hash&amp;ref_src=twsrc%5Etfw\">#proximit\u00e9</a> <a href=\"https://t.co/VDTl379CZ8\">pic.twitter.com/VDTl379CZ8</a></p>&mdash; La Compagnie Rotative (@LaCieRotative) <a href=\"https://twitter.com/LaCieRotative/status/1103384310600687616?ref_src=twsrc%5Etfw\">March 6, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_d33488cc31010b3769311546b90fc0c3%":"1556267052","%_oembed_2aca3e298d417328b6665c0c33cf14d8%":"<iframe width=\"481\" height=\"361\" src=\"https://www.youtube.com/embed/D9FkMjxF-os?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_2aca3e298d417328b6665c0c33cf14d8%":"1556267052","%_oembed_a7acda127bd5e3169e4c56c065673665%":"<blockquote class=\"twitter-tweet\" data-width=\"479\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Ravis d\u2019avoir facilit\u00e9 une belle soir\u00e9e d\u2019intelligence collective sur le th\u00e8me de la mobilit\u00e9 pr les <a href=\"https://twitter.com/hashtag/rdvLaMontagne?src=hash&amp;ref_src=twsrc%5Etfw\">#rdvLaMontagne</a> avec les clermontois ! <a href=\"https://twitter.com/hashtag/proximit%C3%A9?src=hash&amp;ref_src=twsrc%5Etfw\">#proximit\u00e9</a> <a href=\"https://t.co/VDTl379CZ8\">pic.twitter.com/VDTl379CZ8</a></p>&mdash; La Compagnie Rotative (@LaCieRotative) <a href=\"https://twitter.com/LaCieRotative/status/1103384310600687616?ref_src=twsrc%5Etfw\">March 6, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_a7acda127bd5e3169e4c56c065673665%":"1556269426","%_oembed_1765d220de6c9b939f30f2ae90fd08e6%":"<iframe width=\"479\" height=\"359\" src=\"https://www.youtube.com/embed/D9FkMjxF-os?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_1765d220de6c9b939f30f2ae90fd08e6%":"1556269426","%_oembed_5f56987cc1dee340fed63fb253281206%":"<blockquote class=\"twitter-tweet\" data-width=\"482\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">Ravis d\u2019avoir facilit\u00e9 une belle soir\u00e9e d\u2019intelligence collective sur le th\u00e8me de la mobilit\u00e9 pr les <a href=\"https://twitter.com/hashtag/rdvLaMontagne?src=hash&amp;ref_src=twsrc%5Etfw\">#rdvLaMontagne</a> avec les clermontois ! <a href=\"https://twitter.com/hashtag/proximit%C3%A9?src=hash&amp;ref_src=twsrc%5Etfw\">#proximit\u00e9</a> <a href=\"https://t.co/VDTl379CZ8\">pic.twitter.com/VDTl379CZ8</a></p>&mdash; La Compagnie Rotative (@LaCieRotative) <a href=\"https://twitter.com/LaCieRotative/status/1103384310600687616?ref_src=twsrc%5Etfw\">March 6, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_5f56987cc1dee340fed63fb253281206%":"1556276052","%_oembed_93cdb3c07bb27a885f54c3e89db5eea8%":"<iframe width=\"482\" height=\"362\" src=\"https://www.youtube.com/embed/D9FkMjxF-os?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_93cdb3c07bb27a885f54c3e89db5eea8%":"1556276053","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_oembed_1fab216a2d47f47406c459ac8c42671a%":"<iframe title=\"Qu&#039;est-ce que La Compagnie Rotative ?\" width=\"500\" height=\"375\" src=\"https://www.youtube.com/embed/D9FkMjxF-os?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_1fab216a2d47f47406c459ac8c42671a%":"1707421143","taxonomy=category":"Media labs","taxonomy=post_tag":""},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15141,"infowindow_disable":false},{"source":"post","title":"MAS: Nice-Matin\u2019s new innovation space","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"MAS: Nice-Matin\u2019s new innovation space\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2019/03/serie-MediaLabs-nice-matin-600x338-300x169.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">MAS: Nice-Matin\u2019s new innovation space</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            In 2015, Nice-Matin embarked on a profound digital transformation. Faced with major economic difficulties, the daily newspaper opted for a 180-degree turn to establish itself as an innovative media in its own right. Its latest initiative: MAS, the newspaper\u2019s innovation space, launched last January.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/mas-nice-matins-new-innovation-space/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"In 2015, Nice-Matin embarked on a profound digital transformation. Faced with major economic difficulties, the daily newspaper opted for a 180-degree turn to establish itself as an innovative media in its own right. Its latest initiative: MAS, the newspaper\u2019s innovation space, launched last January.","address":"Nice, France","location":{"lat":"43.7101728","city":"Nice","state":"Provence-Alpes-C\u00f4te d'Azur","country":"France","lng":"7.261953199999994","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/mas-nice-matins-new-innovation-space/","zoom":2,"extra_fields":{"post_excerpt":"In 2015, Nice-Matin embarked on a profound digital transformation. Faced with major economic difficulties, the daily newspaper opted for a 180-degree turn to establish itself as an innovative media in its own right. Its latest initiative: MAS, the newspaper\u2019s innovation space, launched last January.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>MAS: Nice-Matin\u2019s new innovation space</h1>\r\n<em>This article was originally published on <a href=\"https://www.meta-media.fr/2019/03/05/le-mas-nouveau-bras-arme-de-linnovation-de-nice-matin.html\">M\u00e9ta-Media</a>, as part of an editorial partnership between M\u00e9ta-Media and WAN-IFRA. The article was written by <a href=\"https://twitter.com/alex_bouniol\">Alexandre Bouniol</a>, France T\u00e9l\u00e9visions, MediaLab.</em>\r\n\r\nIn 2015, Nice-Matin embarked on a profound digital transformation. Faced with major economic difficulties, the daily newspaper opted for a 180-degree turn to establish itself as an innovative media in its own right. Its latest initiative: MAS, the newspaper\u2019s innovation space, launched last January.\r\n\r\nWe had the opportunity to talk with Damien Allemand, head of digital services at Nice-Matin and the MAS initiative, who outlined the strategy, goals and projects of this brand new place for innovation.\r\n<h3>Four development areas</h3>\r\nLaunched in January 2019, MAS is headed by the project manager Marjorie Roubaud-Lubrano, who is accompanied by two consultants. But all of Nice-Matin\u2019s departments are also involved in different degrees, says Damien Allemand, who emphasises the importance of good internal communication \u201cto make sure MAS is not seen as a competing space, and to familiarise the rest of the personnel with it so that they visit and make use of the place. It\u2019s important that the place is on the way for people when they go to the office, that it\u2019s not a closed space [\u2026] as well as bringing in people from outside.\u201d\r\n\r\nIt\u2019s development is based on four strategic areas:\r\n<ul>\r\n \t<li><strong>Incubation of startups</strong> (The MAS startup), which aims to be \u201ca business and success accelerator for local entrepreneurs and businesses\u201d, as <a href=\"http://www.webtimemedias.com/article/avec-le-mas-nice-matin-va-lancer-son-incubateur-accelerateur-20181011-63211\">described</a> by the CEO of the group Jean-Marc Pastorino.</li>\r\n \t<li><strong>Incubation of emerging medias</strong> (The MAS media) to <a href=\"https://medium.com/le-mas-nice-matin/pourquoi-le-mas-nice-matin-sinvestit-aupr%C3%A8s-des-journalistes-entrepreneurs-6b74271fb435\">\u201cinvent the journalists of tomorrow\u201d</a>.</li>\r\n \t<li><strong>The MAS events</strong> to organise conferences on innovation.</li>\r\n \t<li><strong>The MAS training</strong> to train local businesses in digital transformation and communication. The training is provided by Nice-Matin\u2019s specialists and external speakers.</li>\r\n</ul>\r\n<h3>Double incubation, mutual benefits</h3>\r\nDuring the first years of MAS, Nice-Matin welcomed six startups within its premises: <a href=\"https://dibster.co/\">Dibster</a>, <a href=\"https://beeshary.com/\">Bee shary</a>, <a href=\"https://www.facebook.com/miapplicationmobile/\">Deserve Mi</a>, <a href=\"https://www.timenjoy.fr/#/home\">Time N\u2019 Joy</a>, <a href=\"http://readypark.fr/\">Ready Park</a> et <a href=\"https://yomafamily.com/\">Y\u00f6ma Family</a>. <strong>These startups do not develop technical innovations, but offer various services.</strong> For Damien Allemand, even if the firms do not have media activities as such, \u201cthe startups are perfectly coherent with the editorial line of our subscriptions offer\u201d, with \u201cthe reader at the centre of the subscription offer, or on solutions journalism that brings concrete solutions to people\u2019s problems.\u201d For example, Dibster offers for people who have had a flight cancelled or delayed to handle administrative procedures to obtain compensation.\r\n\r\nThe newspaper provides for free its premises for the companies, as well as the possibility to \u201cbeta test\u201d their services with the community of readers as soon as they are viable. The startups promote working methods based on horizontality, agility and mutual support, which can offer new perspectives to daily work within the newspaper.\r\n\r\nhttps://twitter.com/MarjLubrano/status/1100668673352581121\r\n\r\nNice-Matin has also hosted two media in its incubator this year: <a href=\"https://www.switchonpaper.com/\">Switch On Paper</a>, a site that explains news through the prism of contemporary art, and <a href=\"http://www.radionizza.it/\">Radio Nizza</a>, which produces local news in Italian through its blog and podcast. Radio Nizza, for example, lets the newspaper connect with a community who it wouldn\u2019t otherwise reach (Italians in Nice), and invest in the field of podcasting, where Nice-Matin would like to engage more in the future. Damien Allemand speaks even of a \u201ckind of Nice-Matin in Italian\u201d, underlining even more the complementary and mutual benefits these media can offer to each other.\r\n<h3>An economic model to develop</h3>\r\nIn order to finance this new innovation space, Nice-Matin relies on events and training sections of MAS that generate revenues, but also on grants. Some of these are private, through different funds such as those dedicated to the presse by Google, and some public, granted by the French Ministry of Culture. These funds are absolutely necessary for innovation, underlines Damien Allemand: \u201cif I didn\u2019t have all these funds, I would never have been able to lead all these projects\u201d. It also the <a href=\"http://www.culture.gouv.fr/Thematiques/Presse/Aides-a-la-presse/Le-Fonds-de-soutien-a-l-emergence-et-a-l-innovation-dans-la-presse\">support fund for emergence and innovation in the press</a> that permitted the launching of MAS.\r\n\r\nMAS is also economically significant for the newspaper. For Damien Allemand, \u201cit\u2019s a clear diversification\u201d of the group\u2019s activities. This will ultimately allow the discovery of a viable business model:\r\n<blockquote>\u201cIt\u2019s necessary to diversify. So far no one has unlocked the business model. The key will be a combination of solutions which, when put together, will sustain Nice-Matin. The MAS is part of this combination of solutions that will turn around Nice-Matin.\u201d - Damien Allemand</blockquote>\r\n<h3>Permanent innovation</h3>\r\nThe launch of the innovation space is part of a broader framework of innovation of the group. Since 2015, Nice-Matin has launched a multitude of disruptive projects:\r\n<ul>\r\n \t<li>A section dedicated to solutions journalism with <a href=\"https://www.nicematin.com/sujet/solutions\">#MonJournal</a>, a section where subscribers choose the topics for the newsroom to tackle.</li>\r\n \t<li>A chatbot on local news in 2017</li>\r\n \t<li><a href=\"https://kidsmatin.com/\">Kids-Matin</a>, a news media for under 13 year olds; a community included since the beginning of the project in a crowdfunding campaign.</li>\r\n</ul>\r\n[embed]https://youtu.be/5Q12H5A_vfw[/embed]\r\n\r\nThe newspaper plans to continue on this path, and is planning \u201cbackground works\u201d in 2019, starting with the redesign of the website and the subscriber offer.\r\n<blockquote>\u201cWe are trying to build a Netflix for local news\u201d, reveals Damien Allemand.</blockquote>\r\nAnother project launched in parallel this year is the arrival of a robot journalist in the daily\u2019s offices, made possible by <a href=\"https://newsinitiative.withgoogle.com/dnifund/\">funding from Google</a>. It will be a cornerstone of content automatisation, notably for content with little added value such as the weather, allowing journalists to spend more time on other work. An additional task for the robot is data processing; it will be able to alert journalists by highlighting relevant information.\r\n<blockquote>\u201cThe goal will be to liberate journalists\u2019 time so they can go seek higher quality information.\u201d - Damien Allemand</blockquote>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"MAS: Nice-Matin\u2019s new innovation space","post_link":"https://media-innovation.news/media-lab/mas-nice-matins-new-innovation-space/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"MAS: Nice-Matin\u2019s new innovation space\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2019/03/serie-MediaLabs-nice-matin-600x338-300x169.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Media labs","post_tags":"business models, culture of innovation, incubator, startups, training and education","%_edit_lock%":"1564596741:931","%_edit_last%":"931","%_oembed_6b2424674ce1f50df9389bf4c581a010%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">En mode happy, <a href=\"https://twitter.com/hashtag/LeMas?src=hash&amp;ref_src=twsrc%5Etfw\">#LeMas</a> <a href=\"https://twitter.com/Nice_Matin?ref_src=twsrc%5Etfw\">@Nice_Matin</a> est n\u00e9. Le b\u00e9b\u00e9 <a href=\"https://twitter.com/hashtag/Innovation?src=hash&amp;ref_src=twsrc%5Etfw\">#Innovation</a> se porte bien. Nos <a href=\"https://twitter.com/hashtag/Startup?src=hash&amp;ref_src=twsrc%5Etfw\">#Startup</a> are in da place. Bienvenu \u00e0  <a href=\"https://twitter.com/bonjour_dibster?ref_src=twsrc%5Etfw\">@bonjour_dibster</a> , <a href=\"https://twitter.com/BeeShary?ref_src=twsrc%5Etfw\">@BeeShary</a>, <a href=\"https://twitter.com/TimeNjoy?ref_src=twsrc%5Etfw\">@TimeNjoy</a>, Yoma Family, <a href=\"https://twitter.com/ready_park?ref_src=twsrc%5Etfw\">@ready_park</a>, <a href=\"https://twitter.com/deserve_her?ref_src=twsrc%5Etfw\">@deserve_her</a> <a href=\"https://twitter.com/switchonpaper?ref_src=twsrc%5Etfw\">@switchonpaper</a> et Radio Nizza ! <a href=\"https://t.co/Cu8BRCyR3s\">pic.twitter.com/Cu8BRCyR3s</a></p>&mdash; Marjorie Lubrano-Roubaud (@MarjLubrano) <a href=\"https://twitter.com/MarjLubrano/status/1100668673352581121?ref_src=twsrc%5Etfw\">February 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_6b2424674ce1f50df9389bf4c581a010%":"1552577232","%_oembed_dde7516ad4cf533ff011561ed65885c6%":"<iframe width=\"1200\" height=\"675\" src=\"https://www.youtube.com/embed/5Q12H5A_vfw?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_dde7516ad4cf533ff011561ed65885c6%":"1556276168","%_oembed_3b82e0f26b74067aad8c9c91b037c5a2%":"<iframe width=\"562\" height=\"316\" src=\"https://www.youtube.com/embed/5Q12H5A_vfw?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_3b82e0f26b74067aad8c9c91b037c5a2%":"1552577580","%_thumbnail_id%":"15063","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Nice, France","%_wpgmp_location_city%":"Nice","%_wpgmp_location_state%":"Provence-Alpes-C\u00f4te d'Azur","%_wpgmp_location_country%":"France","%_wpgmp_metabox_latitude%":"43.7101728","%_wpgmp_metabox_longitude%":"7.261953199999994","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"60","%_oembed_d984d5504d93a2648b45dd6d4e9d18ac%":"<blockquote class=\"twitter-tweet\" data-width=\"550\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">En mode happy, <a href=\"https://twitter.com/hashtag/LeMas?src=hash&amp;ref_src=twsrc%5Etfw\">#LeMas</a> <a href=\"https://twitter.com/Nice_Matin?ref_src=twsrc%5Etfw\">@Nice_Matin</a> est n\u00e9. Le b\u00e9b\u00e9 <a href=\"https://twitter.com/hashtag/Innovation?src=hash&amp;ref_src=twsrc%5Etfw\">#Innovation</a> se porte bien. Nos <a href=\"https://twitter.com/hashtag/Startup?src=hash&amp;ref_src=twsrc%5Etfw\">#Startup</a> are in da place. Bienvenu \u00e0  <a href=\"https://twitter.com/bonjour_dibster?ref_src=twsrc%5Etfw\">@bonjour_dibster</a> , <a href=\"https://twitter.com/BeeShary?ref_src=twsrc%5Etfw\">@BeeShary</a>, <a href=\"https://twitter.com/TimeNjoy?ref_src=twsrc%5Etfw\">@TimeNjoy</a>, Yoma Family, <a href=\"https://twitter.com/ready_park?ref_src=twsrc%5Etfw\">@ready_park</a>, <a href=\"https://twitter.com/deserve_her?ref_src=twsrc%5Etfw\">@deserve_her</a> <a href=\"https://twitter.com/switchonpaper?ref_src=twsrc%5Etfw\">@switchonpaper</a> et Radio Nizza ! <a href=\"https://t.co/Cu8BRCyR3s\">pic.twitter.com/Cu8BRCyR3s</a></p>&mdash; Marjorie Lubrano-Roubaud (@LeMasNiceMatin) <a href=\"https://twitter.com/LeMasNiceMatin/status/1100668673352581121?ref_src=twsrc%5Etfw\">February 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_d984d5504d93a2648b45dd6d4e9d18ac%":"1556276168","%_yoast_wpseo_primary_category%":"142","%_oembed_4024001c1eede0f50bbd6a40c65e9376%":"<blockquote class=\"twitter-tweet\" data-width=\"484\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">En mode happy, <a href=\"https://twitter.com/hashtag/LeMas?src=hash&amp;ref_src=twsrc%5Etfw\">#LeMas</a> <a href=\"https://twitter.com/Nice_Matin?ref_src=twsrc%5Etfw\">@Nice_Matin</a> est n\u00e9. Le b\u00e9b\u00e9 <a href=\"https://twitter.com/hashtag/Innovation?src=hash&amp;ref_src=twsrc%5Etfw\">#Innovation</a> se porte bien. Nos <a href=\"https://twitter.com/hashtag/Startup?src=hash&amp;ref_src=twsrc%5Etfw\">#Startup</a> are in da place. Bienvenu \u00e0  <a href=\"https://twitter.com/bonjour_dibster?ref_src=twsrc%5Etfw\">@bonjour_dibster</a> , <a href=\"https://twitter.com/BeeShary?ref_src=twsrc%5Etfw\">@BeeShary</a>, <a href=\"https://twitter.com/TimeNjoy?ref_src=twsrc%5Etfw\">@TimeNjoy</a>, Yoma Family, <a href=\"https://twitter.com/ready_park?ref_src=twsrc%5Etfw\">@ready_park</a>, <a href=\"https://twitter.com/deserve_her?ref_src=twsrc%5Etfw\">@deserve_her</a> <a href=\"https://twitter.com/switchonpaper?ref_src=twsrc%5Etfw\">@switchonpaper</a> et Radio Nizza ! <a href=\"https://t.co/Cu8BRCyR3s\">pic.twitter.com/Cu8BRCyR3s</a></p>&mdash; Marjorie Lubrano-Roubaud (@MarjLubrano) <a href=\"https://twitter.com/MarjLubrano/status/1100668673352581121?ref_src=twsrc%5Etfw\">February 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_4024001c1eede0f50bbd6a40c65e9376%":"1552577697","%_oembed_2f4139dde8c9e42654c4880f3dd6f6fe%":"<iframe width=\"484\" height=\"272\" src=\"https://www.youtube.com/embed/5Q12H5A_vfw?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_2f4139dde8c9e42654c4880f3dd6f6fe%":"1552577698","%_kleo_title_checkbox%":"1","%_oembed_6b156bf71921dabb265269416fcd53e6%":"<iframe width=\"483\" height=\"272\" src=\"https://www.youtube.com/embed/5Q12H5A_vfw?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_6b156bf71921dabb265269416fcd53e6%":"1552577863","%_oembed_f5c540eb10ef8bb40fc2af9229be5fff%":"<blockquote class=\"twitter-tweet\" data-width=\"483\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">En mode happy, <a href=\"https://twitter.com/hashtag/LeMas?src=hash&amp;ref_src=twsrc%5Etfw\">#LeMas</a> <a href=\"https://twitter.com/Nice_Matin?ref_src=twsrc%5Etfw\">@Nice_Matin</a> est n\u00e9. Le b\u00e9b\u00e9 <a href=\"https://twitter.com/hashtag/Innovation?src=hash&amp;ref_src=twsrc%5Etfw\">#Innovation</a> se porte bien. Nos <a href=\"https://twitter.com/hashtag/Startup?src=hash&amp;ref_src=twsrc%5Etfw\">#Startup</a> are in da place. Bienvenu \u00e0  <a href=\"https://twitter.com/bonjour_dibster?ref_src=twsrc%5Etfw\">@bonjour_dibster</a> , <a href=\"https://twitter.com/BeeShary?ref_src=twsrc%5Etfw\">@BeeShary</a>, <a href=\"https://twitter.com/TimeNjoy?ref_src=twsrc%5Etfw\">@TimeNjoy</a>, Yoma Family, <a href=\"https://twitter.com/ready_park?ref_src=twsrc%5Etfw\">@ready_park</a>, <a href=\"https://twitter.com/deserve_her?ref_src=twsrc%5Etfw\">@deserve_her</a> <a href=\"https://twitter.com/switchonpaper?ref_src=twsrc%5Etfw\">@switchonpaper</a> et Radio Nizza ! <a href=\"https://t.co/Cu8BRCyR3s\">pic.twitter.com/Cu8BRCyR3s</a></p>&mdash; Marjorie Lubrano-Roubaud (@MarjLubrano) <a href=\"https://twitter.com/MarjLubrano/status/1100668673352581121?ref_src=twsrc%5Etfw\">February 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_f5c540eb10ef8bb40fc2af9229be5fff%":"1552577864","%_oembed_ed30fc162d6c16877668636e0ea1f60b%":"<blockquote class=\"twitter-tweet\" data-width=\"482\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">En mode happy, <a href=\"https://twitter.com/hashtag/LeMas?src=hash&amp;ref_src=twsrc%5Etfw\">#LeMas</a> <a href=\"https://twitter.com/Nice_Matin?ref_src=twsrc%5Etfw\">@Nice_Matin</a> est n\u00e9. Le b\u00e9b\u00e9 <a href=\"https://twitter.com/hashtag/Innovation?src=hash&amp;ref_src=twsrc%5Etfw\">#Innovation</a> se porte bien. Nos <a href=\"https://twitter.com/hashtag/Startup?src=hash&amp;ref_src=twsrc%5Etfw\">#Startup</a> are in da place. Bienvenu \u00e0  <a href=\"https://twitter.com/bonjour_dibster?ref_src=twsrc%5Etfw\">@bonjour_dibster</a> , <a href=\"https://twitter.com/BeeShary?ref_src=twsrc%5Etfw\">@BeeShary</a>, <a href=\"https://twitter.com/TimeNjoy?ref_src=twsrc%5Etfw\">@TimeNjoy</a>, Yoma Family, <a href=\"https://twitter.com/ready_park?ref_src=twsrc%5Etfw\">@ready_park</a>, <a href=\"https://twitter.com/deserve_her?ref_src=twsrc%5Etfw\">@deserve_her</a> <a href=\"https://twitter.com/switchonpaper?ref_src=twsrc%5Etfw\">@switchonpaper</a> et Radio Nizza ! <a href=\"https://t.co/Cu8BRCyR3s\">pic.twitter.com/Cu8BRCyR3s</a></p>&mdash; Marjorie Lubrano-Roubaud (@MarjLubrano) <a href=\"https://twitter.com/MarjLubrano/status/1100668673352581121?ref_src=twsrc%5Etfw\">February 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_ed30fc162d6c16877668636e0ea1f60b%":"1552578073","%_oembed_8069b5baf8f955894852c13199f5e4af%":"<iframe width=\"482\" height=\"271\" src=\"https://www.youtube.com/embed/5Q12H5A_vfw?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_8069b5baf8f955894852c13199f5e4af%":"1552578073","%_oembed_62137f981911d67af80c3d46be8bfe02%":"<blockquote class=\"twitter-tweet\" data-width=\"489\" data-dnt=\"true\"><p lang=\"fr\" dir=\"ltr\">En mode happy, <a href=\"https://twitter.com/hashtag/LeMas?src=hash&amp;ref_src=twsrc%5Etfw\">#LeMas</a> <a href=\"https://twitter.com/Nice_Matin?ref_src=twsrc%5Etfw\">@Nice_Matin</a> est n\u00e9. Le b\u00e9b\u00e9 <a href=\"https://twitter.com/hashtag/Innovation?src=hash&amp;ref_src=twsrc%5Etfw\">#Innovation</a> se porte bien. Nos <a href=\"https://twitter.com/hashtag/Startup?src=hash&amp;ref_src=twsrc%5Etfw\">#Startup</a> are in da place. Bienvenu \u00e0  <a href=\"https://twitter.com/bonjour_dibster?ref_src=twsrc%5Etfw\">@bonjour_dibster</a> , <a href=\"https://twitter.com/BeeShary?ref_src=twsrc%5Etfw\">@BeeShary</a>, <a href=\"https://twitter.com/TimeNjoy?ref_src=twsrc%5Etfw\">@TimeNjoy</a>, Yoma Family, <a href=\"https://twitter.com/ready_park?ref_src=twsrc%5Etfw\">@ready_park</a>, <a href=\"https://twitter.com/deserve_her?ref_src=twsrc%5Etfw\">@deserve_her</a> <a href=\"https://twitter.com/switchonpaper?ref_src=twsrc%5Etfw\">@switchonpaper</a> et Radio Nizza ! <a href=\"https://t.co/Cu8BRCyR3s\">pic.twitter.com/Cu8BRCyR3s</a></p>&mdash; Marjorie Lubrano-Roubaud (@MarjLubrano) <a href=\"https://twitter.com/MarjLubrano/status/1100668673352581121?ref_src=twsrc%5Etfw\">February 27, 2019</a></blockquote><script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>","%_oembed_time_62137f981911d67af80c3d46be8bfe02%":"1552649993","%_oembed_be1f2b2748059e5d821aa7ac99997b7f%":"<iframe width=\"489\" height=\"275\" src=\"https://www.youtube.com/embed/5Q12H5A_vfw?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_be1f2b2748059e5d821aa7ac99997b7f%":"1552649993","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_oembed_f2b83b3509e8f08c4dcaaa796f44e0d8%":"<iframe title=\"Kids-Matin, comment \u00e7a marche ?\" width=\"500\" height=\"281\" src=\"https://www.youtube.com/embed/5Q12H5A_vfw?feature=oembed&amp;wmode=opaque&amp;showinfo=0\" style=\"border: none\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe>","%_oembed_time_f2b83b3509e8f08c4dcaaa796f44e0d8%":"1707419344","taxonomy=category":"Media labs","taxonomy=post_tag":"business models, culture of innovation, incubator, startups, training and education"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":15060,"infowindow_disable":false},{"source":"post","title":"The Annenberg Innovation Lab: &#8216;Think and Do Tank&#8217; at the University of Southern California (USC)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Annenberg Innovation Lab: &#8216;Think and Do Tank&#8217; at the University of Southern California (USC)\" width=\"300\" height=\"150\" src=\"https://media-innovation.news/wp-content/uploads/2018/09/AnnLab_360-300x150.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">The Annenberg Innovation Lab: &#8216;Think and Do Tank&#8217; at the University of Southern California (USC)</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Headed up by Colin Maclay, they combine nimbleness and network to be innovative both in their local community and on a national scale.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/the-annenberg-innovation-lab/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Headed up by Colin Maclay, they combine nimbleness and network to be innovative both in their local community and on a national scale.","address":"University of Southern California, Los Angeles, CA, USA","location":{"lat":"34.0223519","lng":"-118.28511700000001","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/the-annenberg-innovation-lab/","zoom":2,"extra_fields":{"post_excerpt":"Headed up by Colin Maclay, they combine nimbleness and network to be innovative both in their local community and on a national scale.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>The Annenberg Innovation Lab: 'Think and Do Tank' at the University of Southern California (USC)</h1>\r\n<strong>Headed up by Colin Maclay, they combine nimbleness and network to be innovative both in their local community and on a national scale.</strong>\r\n\r\nMaclay has been at the Lab for two years, having previously worked at Harvard Business School. The former head of the lab made the decision to wind down any projects they had running prior to Maclay\u2019s start in the role. This meant he had a fresh slate and a chance to assess their practices:\r\n<blockquote>\u201cI think we needed a reflection period. As with any organisation, but especially with a so-called innovation lab, we need to be reflecting on our practice and what we focus on with regularity,\"\u00a0Maclay says. \"The world is changing rapidly and we don\u2019t want to build an engine that worked for the environment five years ago. We want to continue to challenge ourselves, to adapt, pivot and ensure that we\u2019re being responsive to the current moment.\u201d</blockquote>\r\nMaclay felt he needed to understand a bit more about what was going on around Los Angeles and USC, having come from the East Coast and Boston:\r\n<blockquote>\u201cI really needed to figure out what was happening, to get a sense of what was on offer already, where the gaps were. It was really about getting a sense of what the resources were that we could activate. Or the role that we could play as a small organisation.\u201d</blockquote>\r\nIt doesn\u2019t just end there however. Maclay suggests there needed to be a greater understanding of what other people were doing, what the industry were already creating themselves:\r\n<blockquote>\u201cYou don\u2019t want to duplicate what other folks are already doing or can do better. We want to leverage our nimbleness. It started with that and then I reached out to colleagues and the funding world to see what issues they were working on, interested in, investing in and look for places where I felt that overlapped with our skillset as a lab.\u201d Maclay added.</blockquote>\r\n<h3>Building your muscles</h3>\r\nAfter understanding what the media landscape looked like, the natural progression was to decide where the lab wants to focus its time. The lab has a core team of four dedicated staff as well as a mixed group of faculty and students who do work on various projects. Outside of that there is a wide collaborative network that they are engaged with, but it\u2019s important for the team to be constantly interacting without outside collaborators as they are a small group.\r\n<blockquote>\u201cThe new ideas and insights come from the edges. They don\u2019t come from the people who have been working on that thing forever. So creating fluid, dynamic and networked communities to work on different challenges and opportunities is key.\u201d</blockquote>\r\nAt this point the lab had no active projects, no income or revenue. This played a part in the choosing of projects at this stage in the life of the lab. They need to be self sustaining, Maclay suggests:\r\n<blockquote>\u201cThe university doesn\u2019t want to pay for us, they want us to be self sustaining and they want us to contribute to the intellectual community and life of the university, to look good for them. Our incentives are aligned.\u201d</blockquote>\r\nSo how do they become self sustaining and generate revenue whilst also contributing to the intellectual community?\r\n<blockquote>\u201cThere were projects that I felt were gas in the tank in terms of money, challenges, things to chew on to get us moving. If you think about a boat: if you\u2019re not moving you can\u2019t steer, you\u2019ve got to be moving to steer.\u201d\r\n\r\n\u201cI identified a few projects that were interesting and meaningful. Projects that would help us to rebuild or build our practices, a community, our processes and our ties within the community. Those initial projects were things that we could get money for and that would help us to build our muscles, so that as we got a better sense of the place where we really wanted to go, we could invest and engage in those areas.\u201d</blockquote>\r\nThrough this approach and careful development, in the past two years Maclay has built a maturing portfolio that will allow his lab to grow, both in terms of reputation and learning. Something that will allow it to \u2018build their muscles\u2019 as an organisation and plan for where they want to go in the coming years.\r\n\r\nSome of the current projects include monitoring air pollution in cities and mapping a cleanest route to work for cyclists. This involves the use of pollution monitors on the corner of several \u201cblocks\u201d across the city to make provide highly accurate readings for people.\r\n<h3>21st Century Census</h3>\r\nPerhaps the most groundbreaking project the Annenberg Innovation Lab are working on is the digitisation of the American census. The census aims to count every person in the US broken down by state, county and city, with the next decennial census due in 2020. Since the last US census in 2010, there has been significant advancements in the technology industry, making something like a digital version possible. Maclay says that California state is not only the hardest to count state, but Los Angeles county is the hardest to count county for the census as well.\r\n<blockquote>\u201cIt has both a local and a national element. It connects to our interest in city and community, and it is also at the intersection of media tech and culture, which is important to us. The census directs the order of 7 or 800 billion dollars of US federal spending manually as well as determining congressional apportionments and representation for the state in congress.\u201d\r\n\r\n\u201cIt\u2019s interesting from a research perspective. We\u2019ve got students involved and it\u2019s a place where other organisations, for profit or not, also have a stake. The scale is just insane! Some 200,000 organisations work on the census, ranging from companies to philanthropy to the bureau to state level government.\u201d</blockquote>\r\nMaclay believes success for this project is about finding the right skills balance. Some people involved in the production of the census are skilled in certain things, so it\u2019s important to utilise specialists in their own areas to develop the best result.\r\n\r\nThis project will really come into its own before the 2020 census and is another example of how Maclay has curated his portfolio of projects to encompass the local community and have impact on potentially a national scale.\r\n\r\nCONTACT POINT\r\n<img class=\"alignnone wp-image-11787 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2018/09/colin-maclay-e1536847436130.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\nColin Maclay, Executive Director, Annenberg Lab\r\nWeb: <a href=\"http://www.annenberglab.com\" target=\"_blank\" rel=\"noopener\">www.annenberglab.com</a>\r\nTwitter: <a href=\"https://twitter.com/cmac\" target=\"_blank\" rel=\"noopener\">@cmac</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"The Annenberg Innovation Lab: &#8216;Think and Do Tank&#8217; at the University of Southern California (USC)","post_link":"https://media-innovation.news/media-lab/the-annenberg-innovation-lab/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Annenberg Innovation Lab: &#8216;Think and Do Tank&#8217; at the University of Southern California (USC)\" width=\"300\" height=\"150\" src=\"https://media-innovation.news/wp-content/uploads/2018/09/AnnLab_360-300x150.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic Lab, urban innovation, USA","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1562229131:931","%_edit_last%":"101","%_thumbnail_id%":"11785","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"University of Southern California, Los Angeles, CA, USA","%_wpgmp_metabox_latitude%":"34.0223519","%_wpgmp_metabox_longitude%":"-118.28511700000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545526388,"payload":[{"id":10942},{"id":10681},{"id":11765}]}},"taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic Lab, urban innovation, USA"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11784,"infowindow_disable":false},{"source":"post","title":"Monday Innovation Lab: Innovating step-by-step, while aiming for Utopia","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Monday Innovation Lab: Innovating step-by-step, while aiming for Utopia\" width=\"300\" height=\"157\" src=\"https://media-innovation.news/wp-content/uploads/2018/09/36064818_2059901234270256_4564305197643333632_o-300x157.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Monday Innovation Lab: Innovating step-by-step, while aiming for Utopia</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            When you think of innovation labs, you probably imagine a room of people figuring out the next groundbreaking app or tool. Monday Innovation Lab is taking innovation citywide.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/monday-innovation-lab/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"When you think of innovation labs, you probably imagine a room of people figuring out the next groundbreaking app or tool. Monday Innovation Lab is taking innovation citywide.","address":"Barcelona, Spain","location":{"lat":"41.38506389999999","lng":"2.1734034999999494","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/monday-innovation-lab/","zoom":2,"extra_fields":{"post_excerpt":"When you think of innovation labs, you probably imagine a room of people figuring out the next groundbreaking app or tool. Monday Innovation Lab is taking innovation citywide.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Monday Innovation Lab: Innovating step-by-step, while aiming for Utopia</h1>\r\n<strong>When you think of innovation labs, you probably imagine a room of people figuring out the next groundbreaking app or tool. Monday Innovation Lab is taking innovation citywide.</strong>\r\n\r\nSituated in Barcelona, the Monday Innovation Lab helps cities in Catalonia, small or large, to innovate and adapt to new challenges. Having only been active for 18 months, the Lab is still in its infancy, but it aims to address four key urban issues - youth unemployment, the elderly, the digital gender gap, and custom projects - in novel ways: \u201cFor me innovating is doing something different,\" says Patricia Gonzalez Garcia, founder of Monday Innovation Lab. \"With the aim to achieve different results.\u201d\r\n\r\nThis belief is applied to rigid and sometimes difficult to maneuver local governments. The structure of Barcelona\u2019s City Hall is not foreign to Gonzalez, having worked inside for eight years before realising innovation and the process, methodology and technology of innovation is needed everywhere.\r\n\r\nGonzalez works with governments that are keen to change, but may not quite have the right tools or skill set. They may not know how to connect effectively with citizens or how to utilise a new technology. That\u2019s where she steps in:\r\n<blockquote>\"My mission is to help local governments that want to innovate; not help the people that don't know that they have to innovate.\u201d</blockquote>\r\n<h3>Bespoke Team Building</h3>\r\nThe lab itself is just Gonzalez - she detects opportunities, starts projects and liaises with the city halls that want to innovate. Having honed her skills in Barcelona before taking them across the Atlantic to the US, Gonzalez has built up a wide network of contributors and potential collaborators.\r\n\r\nAfter identifying a potential project there could be an ideation or co-creation session to try and define the issue and plan a course of action. Next, Gonzalez creates a team:\r\n<blockquote>\u201cI don\u2019t have a permanent team because this would mean I always have to give the same solution to everybody. I connect to different people with different skills and create project-specific teams. I\u2019m like a hub!\u201d</blockquote>\r\nBut this lab isn\u2019t just about quick fixes and short-term solutions: \u201cWe create a team with the aim that when we finish the project, the project will last.\u201d\r\n<h3>Innovating from a sentence</h3>\r\nOne such project built to last is \u201cI\u2019m Blogger\u201d - a citizen journalism initiative for the elderly and retirees, born from an unlikely beginning:\r\n<blockquote>\u201cThe deputy mayor said to the director of elderly people at Barcelona City Hall \u2018I want the elderly to write on the facebook page of the municipality.\u2019 That\u2019s all,\u201d remembers Gonzalez.</blockquote>\r\nSo how do you innovate and create from just 13 words? Gonzalez unpicked this single sentence to decide what could be done. As she realised this could be scaled up and taken further than simple interaction on Facebook, a few words from the deputy major turned into a full-fledged project for citizen journalism.\r\n\r\nAfter an initial pilot with nine participants, Gonzalez decided they needed a physical space where the participants could interact and engage with each other:\r\n<blockquote>\u201cWe are human and of course we are used to working with computers and our mobile phones every day, but we need the human touch. We need to go to a bar or a cafe to talk with people. This is where you really exchange ideas. Physical spaces are needed sometimes in the first stage. A place somewhere that is open all day, every day and where you can go and ask questions or ask someone how to do something. This mindset is promoted when you have a specific space for that.\u201d</blockquote>\r\nThe project grew from the pilot into what it has become now, a communication and social network for the elderly in Barcelona. Gonzalez places a strong focus on having users involved at all stages of product development. This allows them to grow and develop in line with what the users want and need from the project:\r\n<blockquote>\u201cThey are always giving us feedback and we are doing sessions to refine the prototype. We are changing the programme every time to engage more people. They like creating the programme for other people with us and to engage other people and so on and so on. I am really proud of this project.\u201d</blockquote>\r\n<h3>Aiming for Utopia</h3>\r\nWhen it comes to projects, Gonzalez believes it\u2019s important to keep a broader vision of what you\u2019re creating and be aware of how it can really change the lives of citizens. She hopes to push the project further and create a real impact in the city:\r\n<blockquote>\u201cI want to see the community that have learned all these skills, experienced this process and then be really passionate for writing about their city. To move beyond what the deputy mayor asked. He gave us a direction, but we can grow a citizen movement that can give value to the city.\u201d</blockquote>\r\nAnd it doesn\u2019t end there. Gonzalez always holds a vision for where the project should go: \u201cYou always have to have a Utopia because that\u2019s your aim, that is your North and where you want to go. But you have to start with the first step.\u201d\r\n\r\nIn this case the first step was the pilot, coming from 13 words and has become a network of citizen journalists, enriching a city and providing it a base upon which the elderly can create content.\r\n\r\nGonzalez hopes to take her skills and insights to other cities in the future, there\u2019s currently a lot of growth in the industry within Catalonia but the aim is a bit further afield. Gonzalez is looking to build a core team around her, without diluting the quality of work or the vision she holds. When that becomes a reality, she hopes projects in both the US and Europe will become more accessible.\r\n\r\nCONTACT POINT\r\n<img class=\"alignnone wp-image-11775 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2018/09/Pat-e1536228159598.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\nPatricia Gonzalez Garcia, Founder, Monday Innovation Lab\r\nWeb: <a href=\"http://mondaybarcelona.com/\" target=\"_blank\" rel=\"noopener\">http://mondaybarcelona.com/</a>\r\nTwitter: <a href=\"https://twitter.com/Pat_GG\" target=\"_blank\" rel=\"noopener\">@Pat_GG</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Monday Innovation Lab: Innovating step-by-step, while aiming for Utopia","post_link":"https://media-innovation.news/media-lab/monday-innovation-lab/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Monday Innovation Lab: Innovating step-by-step, while aiming for Utopia\" width=\"300\" height=\"157\" src=\"https://media-innovation.news/wp-content/uploads/2018/09/36064818_2059901234270256_4564305197643333632_o-300x157.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"citizen journalism, elderly, network, Spain, urban innovation","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1562267612:1","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Barcelona, Spain","%_wpgmp_metabox_latitude%":"41.38506389999999","%_wpgmp_metabox_longitude%":"2.1734034999999494","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%_thumbnail_id%":"11778","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545393990,"payload":[{"id":11412},{"id":11235},{"id":11024}]}},"%_kleo_title_checkbox%":"1","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"citizen journalism, elderly, network, Spain, urban innovation"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11770,"infowindow_disable":false},{"source":"post","title":"Stanford Computational Journalism Lab: Laying the foundations of US data journalism","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stanford Computational Journalism Lab: Laying the foundations of US data journalism\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2018/08/15823-journalism_news-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Stanford Computational Journalism Lab: Laying the foundations of US data journalism</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Working from the ground up, Stanford University is taking a new approach to innovation to provide platforms for journalists to tell stories that would otherwise go untold. \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/11765/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Working from the ground up, Stanford University is taking a new approach to innovation to provide platforms for journalists to tell stories that would otherwise go untold. ","address":"Stanford, CA, USA","location":{"lat":"37.42410599999999","lng":"-122.1660756","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/11765/","zoom":2,"extra_fields":{"post_excerpt":"Working from the ground up, Stanford University is taking a new approach to innovation to provide platforms for journalists to tell stories that would otherwise go untold. ","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Stanford Computational Journalism Lab: Laying the foundations of US data journalism</h1>\r\n<b>Working from the ground up, Stanford University is taking a new approach to innovation to provide platforms for journalists to tell stories that would otherwise go untold. </b>\r\n\r\nFrom covering hackable voting machines to analysing police stops, Stanford are using data journalism to change public policy and raise awareness for the issues in America today. They aim to create real world change through their efforts, and have no intention of stopping.\r\n\r\nThe lab, founded in 2014, is one branch of the larger Stanford Journalism network, consisting of the <a href=\"https://media-innovation.news/media-lab/brown-institute-media-innovation-cross-pollinating-innovation-magic-americas-coasts/\" target=\"_blank\" rel=\"noopener noreferrer\">Brown Institute for Media Innovation</a> (a collaboration between Columbia Journalism School and the Stanford University\u2019s School of Engineering) <span style=\"font-weight: 400;\">and The Stanford Daily Newspaper. Here they teach students how to extract and use data to enhance stories or uncover new stories. It is headed up by co-founder Cheryl Phillips but it is very much a fluid network of people who contribute. The lab's mission is twofold: lower the cost of \u2018accountability journalism\u2019 and use computational methods to help uncover stories that would otherwise go untold.</span>\r\n\r\nPhillips has been teaching journalism at Stanford University since 2014. Having previously worked at the Seattle Times for more than a decade, with her most recent role being Data Innovation Editor, Phillips is no stranger to the world of media innovation:\r\n<blockquote>\u201cWe want to help journalists tell stories in a more personalised and engaging way. That could be helping to build tools, to process data. We take care of the plumbing so the journalists can do the story.\u201d</blockquote>\r\n<h3>Big Local News</h3>\r\nPhillips\u2019 main focus currently lies with the Big Local News project where the goal is to develop partnerships across newsrooms to collect data, process it and make it available for journalists. Reporters can also save their data in the Stanford Digital Library Repository for as long as needed. This library is a digital space dedicated to making content accessible for future generations. In return for local journalists using this service, they get a persistent URL they can share out and don\u2019t have to worry about their server changing or their system going down.\r\n\r\nAdditionally, Jonathan Stray, a journalist and lecturer from Columbia University, is working on a \u2018computer journalism workbench\u2019 (currently in beta), which is part of Big Local and it will be one of the tools used by journalists.\r\n<blockquote>\u201dThe whole idea with that is to analyse data without having to code, so it\u2019s built on Python (a programming language) but if you\u2019re a journalist who doesn\u2019t really know how to use that software you can use these modules to figure out how to analyse information,\u201d says Phillips.</blockquote>\r\nThis work is that Phillips refers to as \u201cdoing the plumbing\u201d, the kind of work that\u2019s underground, not seen or thought about most of the time, but work which is absolutely essential to local news publishers and local journalists that are stretched for both time and money.\r\n<h3>Structuring the Innovation Network</h3>\r\nThere are several different branches to the Stanford Journalism network including the Brown Institute and The Stanford Daily, so what does it look like? Phillips describes it as a \u201cvery fluid\u201d structure, their seminars and workshops are taught by a variety of industry professionals ranging from the head of the Brown Institute, Maneesh Agrawala, to Krishna Bharat the founder of Google News. The department is free to investigate and flesh out different projects as they see fit, to create more conversations around topics, to foster collaborations and build partnerships throughout the industry.\r\n\r\nThis licence to follow their journalistic instinct has allowed them much more freedom when it comes to selecting projects. Phillips suggests they aren\u2019t motivated by a need to generate revenue, but rather their focus is on impact in some form:\r\n<blockquote>\u201cWhat we\u2019re going for is some kind of impact, changing policy if possible, just like with any kind of investigative journalism.\u201d</blockquote>\r\nBut that is not the only driver. When someone comes to Phillips with a project or an idea she always tries to involve a newsroom if there is one interested. This not only gives those students a glimpse into a real newsroom but it helps them create a network and gain experience alongside real professionals.\r\n\r\nThere a few other key things Phillips look for in a project: is it new and does it have potential for change or reform? What is the minimum story that can be told? If all else fails is there still a story to be told? What could the maximum story be; just how far can this story go?\r\n<h3>Mapping Hackable voting machines</h3>\r\nThis approach led to their work around \u201chackable\u201d voting machines in Pennsylvania. The data journalism students investigated voting machines that were judged to be low tech and at risk of being hacked for each county in the state.\r\n\r\nIn ten weeks they mapped data for who had plans to upgrade their machines or not before the next voting cycle and published their findings in an article for the Philadelphia Inquirer. The results were that the county changed their policy on voting machines so that all counties, not just the four that planned to, updated their machines.\r\n\r\nThis is what this lab is aiming for; real world change as a result of doing these sorts of stories, building platforms so they don\u2019t go untold and, maybe most importantly, to keep accountability journalism low cost and easy for reporters.\r\n<h3>Problem solving through Innovation</h3>\r\nOn the broader topic of innovation Phillips says she looks to identify unmet needs and see how the structures or collaborations to fulfill those needs could be changed. They don\u2019t however try to innovate from a standing start, says Phillips.\r\n<blockquote>\u201cI think it\u2019s innovate off the back of [an issue] and solve a problem that\u2019s kind of where our focus is. There\u2019s so many stresses on local journalism and accountability journalism that there\u2019s no shortage of problems. So we just try to tackle those where we can although sometimes I think the problems have as yet been unidentified.\u201d</blockquote>\r\nOne of these many stresses on local journalism led to the introduction of the Big Local project:\r\n<blockquote>\u201cThe idea is to collect local data sets that lend themselves to investigative or accountability journalism, then help local newsrooms with those and also aggregate data sets for bigger impact stories. People may have thought about doing something like this before, but they weren\u2019t \u201crunning around saying \u2018hey somebody has to do this\u2019\u201d Phillips added.</blockquote>\r\n<h3>The Future</h3>\r\nThe media landscape is ever changing, but the Lab\u2019s approach to innovation may be something that is quite consistent. Going forward, Phillips suggests that other universities looking to follow in their footsteps shouldn\u2019t be afraid to make mistakes, rather to make them, learn and improve. As well as \u201cjust start teaching data journalism to your students\u201d.\r\n\r\nA study conducted by Phillips and Charles Berret, into journalism schools in the USA found that a little more than half regularly offered one or more data journalism class, but most of those classes were \u2018basic\u2019. The courses taught excel spreadsheets rather than programming skills and in 54 out of 113 cases, no data journalism course was taught.\r\n\r\nThe approach Cheryl Phillips takes to the future and what innovation may bring is something that anyone involved in the media innovation world should take on board:\r\n<blockquote>\u201cI think one of the things about newspapers in history, that you sometimes don\u2019t get online, is that sense of serendipity, you might find a story you didn\u2019t know you\u2019d be interested in and then you read it...and it expands your horizons. Well the same thing is true of innovation.</blockquote>\r\n<blockquote>I don\u2019t know what they next tool might be. I hope I\u2019m a part of it and the way I can make sure I\u2019m going to be a part of it is to foster these conversations. Whether it\u2019s a tool or an effort five years down the road I\u2019m not sure what it\u2019s all going to look like.</blockquote>\r\n<blockquote>I have no doubt that the next time we have the computational journalism seminar, somebody will probably have an idea that won\u2019t even be something I\u2019ve thought of right and that\u2019s that serendipity.Creating a ground for serendipitous moments that will help journalism.\u201d</blockquote>\r\nCONTACT POINT\r\n<img class=\"alignnone wp-image-11746 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2018/08/cephillips1-e1536227584932.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\nCheryl Phillips, Co-Founder, Stanford Computational Journalism Lab\r\nWeb: <a href=\"http://cjlab.stanford.edu/\" target=\"_blank\" rel=\"noopener noreferrer\">http://cjlab.stanford.edu/</a>\r\nTwitter: <a href=\"https://twitter.com/cephillips\" target=\"_blank\" rel=\"noopener noreferrer\">@cephillips</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Stanford Computational Journalism Lab: Laying the foundations of US data journalism","post_link":"https://media-innovation.news/media-lab/11765/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stanford Computational Journalism Lab: Laying the foundations of US data journalism\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2018/08/15823-journalism_news-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic Lab, data journalism, USA","%_edit_lock%":"1562315716:931","%_edit_last%":"931","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Stanford, CA, USA","%_wpgmp_metabox_latitude%":"37.42410599999999","%_wpgmp_metabox_longitude%":"-122.1660756","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%_thumbnail_id%":"11742","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545412797,"payload":[{"id":11032},{"id":10681},{"id":11024}]}},"%_kleo_title_checkbox%":"1","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic Lab, data journalism, USA"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11765,"infowindow_disable":false},{"source":"post","title":"Mediati: incubating new media startups to shake up the legacy media landscape","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mediati: incubating new media startups to shake up the legacy media landscape\" width=\"300\" height=\"225\" src=\"https://media-innovation.news/wp-content/uploads/2018/08/21742986_1607761379294553_2580961318737310596_n-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Mediati: incubating new media startups to shake up the legacy media landscape</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            \"If content from old media cannot compete with a 22-year old YouTuber, that\u2019s a problem,\u201d says Mediati's Content Strategist Simon Park.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/mediati-incubating-new-media-startups-to-shake-up-the-legacy-media-landscape/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"\"If content from old media cannot compete with a 22-year old YouTuber, that\u2019s a problem,\u201d says Mediati's Content Strategist Simon Park.","address":"Seoul, South Korea","location":{"lat":"37.566535","lng":"126.97796919999996","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/mediati-incubating-new-media-startups-to-shake-up-the-legacy-media-landscape/","zoom":2,"extra_fields":{"post_excerpt":"\"If content from old media cannot compete with a 22-year old YouTuber, that\u2019s a problem,\u201d says Mediati's Content Strategist Simon Park.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Mediati: incubating new media startups to shake up the legacy media landscape</h1>\r\n<strong>\"If content from old media cannot compete with a 22-year old YouTuber, that\u2019s a problem,\u201d says Mediati's Content Strategist Simon Park.\r\n</strong>\r\n\r\nCreated in 2016, Mediati aims to address issues with the legacy media in South Korea. According to the lab's Content Strategist Simon Park, they are not transparent about their relations with advertisers and their content is often out-dated:\r\n<blockquote>\u201cBecause old media didn\u2019t have to improve user experience, their product is advertisement, and it\u2019s based on the numbers, not the actual experience of the audience. So it\u2019s really out-dated content that doesn\u2019t work on social media. I\u2019m not saying social media or big platforms are our future, but if content from old media cannot compete with a 22-year old YouTuber, that\u2019s a problem.\u201d</blockquote>\r\nThe idea was to lure young journalism graduates into starting their own innovative companies before legacy media organisations swoop them up. Two years later, it turns out harder to find media startups than the Mediati team had hoped. Instead of the expected 20, they just got their 14th team on board:\r\n<blockquote>\u201cOne thing that we found over the past two years is that it\u2019s not easy for us to find new media startups in the Korean market. Young people don't think they have the opportunity to create a company and would rather go to the legacy media to start their careers.\u201d</blockquote>\r\n<h3>Selection of startups</h3>\r\nThe incubator is open to anyone in principal. They have an open mentoring program; a 1,5 hour session each month that anyone can apply for:\r\n<blockquote>\u201cWe do this thing called Product Field: a German method of product development, that we changed to fit a media model. It helps you find out in less than an hour who your audience is, your product, and possible business models.\u201d</blockquote>\r\nMediati works with Google Korea. Some of the most successful teams that Mediati ends up training and investing in come from their Google News Lab, that takes place each year from mid-December to the end of February. Since it's mainly college students applying for the program, it makes sense to organise it during their winter break.\r\n<blockquote>\u201cWe teach them the basics of how new media works. After two months we see who are interested in starting a new media and we can actually see who is talented already, and they get a bit of a leg up. They are really talented people, so the competition for them is really high.\u201d</blockquote>\r\n<h3>Helping young people start media companies</h3>\r\nSelected startups go into a six-month incubation program, which starts with audience research, in the form of interviews:\r\n<blockquote>\"One of the startups actually gave up their product. It was the first time they met their audience. They did these one-hour interviews with them and found out that no one wants their product. But finding that out in two weeks is great. And asking their audiences what information they need but currently lack helped them come up with a different product.\u201d</blockquote>\r\nNext, the teams develop their products, and Mediati provides mentoring by simply talking to them about their products and asking questions they had not thought about themselves: \u201cWe just talk to them so they realise better what they are doing.\u201d\r\n\r\nFinally, they cover the business details, preparing the teams for the next investment round. Mediati spends a lot of time teaching business skills, because even when journalism graduates pursue this path of creating their own company, they lack the entrepreneurial mindset necessary. They were taught to listen to lectures and then create content, explains Simon:\r\n<blockquote>\u201cThey grew up thinking about creating content, not a business. The idea of a working business model can be new to them. So we have to start from there. What is a business? What is the difference between running a business and being a YouTuber? Not many people see that difference.\u201c</blockquote>\r\n<h3>Learning and adapting faster</h3>\r\nSimon believes that the Mediati startups provide real added value to the Korean media landscape:\r\n<blockquote>\u201cThey\u2019re so different and innovative because they\u2019re learning to create things, by themselves, by watching YouTube videos, instead of learning how they should do it in the legacy companies.\u201d</blockquote>\r\nIt\u2019s important to nourish this, says Simon, as the risk is that young people go into legacy media companies and quickly learn how to work like the others. He draws a parallel with the Teams that apply for the Google Korea incubator:\r\n<blockquote>\u201cMost of the videographers and designers that apply for the program did not major in these subjects. They are auto-didacts, having learned from watching YouTube videos, which means they have more up to date skills, are learning faster, and adopting new ways of working more easily.\u201d</blockquote>\r\n<h3>Investment for Impact</h3>\r\nThe incubator is funded by an investor. \u201cWe are totally independent,\u201d says Simon Park about the relationship with their investor. \u201cAll that he asks is that we\u2019re more aggressive.\u201d\r\n\r\nHaving already developed a lucrative business as an online entrepreneur \u2013 being the founder of Daum, one of Korea\u2019s top web portals - the investor is not expecting any profit from the startups, and the 40 000 dollars in seed funding he provided is peanuts to him, says Simon. Fortunately, because the media for equity Mediati gets is only 10 per cent and the startups are not making any money yet. According to Simon, his motivations are more related to social impact and challenging the current media landscape:\r\n<blockquote>\u201cHe had some contact with old media and he didn\u2019t like it, because their business is not really transparent in terms with their relationships with the advertisers, their going for the number of clicks. He doesn\u2019t like the state of Korean media and I totally agree with him. So his goal is not having a new media under his belt. But if there\u2019s a couple of new media that can shake up this media world in Korea, it will be meaningful for us.\u201d</blockquote>\r\n<h3>After the incubator</h3>\r\nThe challenge is to find deep-pocketed investors to continue after the six months in the incubator are over. Although it\u2019s too early to say anything in terms of actual results, one of the startups did find a partnership with a movie studio for example: \u201cIn that particular case, it was not an investment, but sponsored content opportunities, which is a decent model for the media.\u201d\r\n\r\nAt the same time, investors like to see these kinds of industry relationships, according to Simon, and there\u2019s also increasingly interest from legacy media companies:\r\n<blockquote>\u201cIt didn\u2019t happen yet, but they are showing some interest in buying them. For example the owner of an all-print interior design magazine, one of the largest in South Korea, wanted to digitalize their content. She told us she gave up because there was a huge resistance from her paper-based editors. She was looking for new media editors to work on this instead. The deal didn\u2019t go through, but it shows a change in thinking.\u201d</blockquote>\r\nThis is an encouraging sign as Mediati hopes to shake up the legacy media landscape in South Korea. However, so far the change seems to be coming to legacy media through global corporations, like DailyMotion and VICE. As they're looking to set up Korean offices, they reach out to new media initiatives like Mediati.\r\n\r\nCONTACT POINT\r\n<img class=\"alignnone size-full wp-image-11739\" src=\"https://gami.wan-ifra.org/wp-content/uploads/2018/08/Simon-Park.jpeg\" alt=\"\" width=\"200\" height=\"250\" />\r\nSimon Park, Content Lab Strategist, Mediati\r\nWeb: <a href=\"http://mediati.kr/\" target=\"_blank\" rel=\"noopener\">http://mediati.kr/</a>\r\nFacebook: <a href=\"https://www.facebook.com/mediati.kr/\" target=\"_blank\" rel=\"noopener\">@mediati.kr</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Mediati: incubating new media startups to shake up the legacy media landscape","post_link":"https://media-innovation.news/media-lab/mediati-incubating-new-media-startups-to-shake-up-the-legacy-media-landscape/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mediati: incubating new media startups to shake up the legacy media landscape\" width=\"300\" height=\"225\" src=\"https://media-innovation.news/wp-content/uploads/2018/08/21742986_1607761379294553_2580961318737310596_n-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"business models, content, incubator, Product Field, South Korea, startups","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1535011735:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Seoul, South Korea","%_wpgmp_metabox_latitude%":"37.566535","%_wpgmp_metabox_longitude%":"126.97796919999996","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_primary_category%":"69","%_thumbnail_id%":"11735","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545509600,"payload":[{"id":11833},{"id":10783},{"id":11553}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"business models, content, incubator, Product Field, South Korea, startups"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11732,"infowindow_disable":false},{"source":"post","title":"Ouest M\u00e9dialab: a cluster and independent media lab that supports the regional digital transition","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ouest M\u00e9dialab: a cluster and independent media lab that supports the regional digital transition\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2018/08/2HybLabRcitsInteractifsRennes2016-600x400-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Ouest M\u00e9dialab: a cluster and independent media lab that supports the regional digital transition</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Ouest M\u00e9dialab brings together a variety of actors around digital innovation projects in the French regions Pays de la Loire and Bretagne. \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/ouest-medialab-a-cluster-and-independent-media-lab-that-supports-the-regional-digital-transition/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Ouest M\u00e9dialab brings together a variety of actors around digital innovation projects in the French regions Pays de la Loire and Bretagne. ","address":"Nantes, France","location":{"lat":"47.218371","lng":"-1.553621000000021","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/ouest-medialab-a-cluster-and-independent-media-lab-that-supports-the-regional-digital-transition/","zoom":2,"extra_fields":{"post_excerpt":"Ouest M\u00e9dialab brings together a variety of actors around digital innovation projects in the French regions Pays de la Loire and Bretagne. ","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Ouest M\u00e9dialab: a cluster and independent media lab that supports the regional digital transition</h1>\r\n<em>This article was originally published on <a href=\"https://www.meta-media.fr/2018/07/19/ouest-medialab-un-cluster-et-laboratoire-des-medias-qui-accompagne-les-acteurs-regionaux-dans-leur-transition-numerique.html\" target=\"_blank\" rel=\"noopener\">M\u00e9ta-Media</a>, as part of an editorial partnership between M\u00e9ta-Media and WAN-IFRA. The interview was conducted by Fran\u00e7ois Fluhr, France T\u00e9l\u00e9visions, Prospective and Media Lab \u00a9 [2018] All rights reserved.</em>\r\n\r\n<strong>With a geographical focus on West France, Ouest M\u00e9dialab brings together a variety of actors around digital innovation projects in the regions Pays de la Loire and Bretagne.</strong>\r\n\r\nAfter it was created in 2012, the lab needed some time to mature, assemble a sufficient number of people, and put in place a road map. It started its activites in 2013, around four strategic axes that remain the pillars of the project today:\r\n<ul>\r\n \t<li>The ambition to develop the skills of the teams involved and to create synergies between different professions. This is a specific challenge in the media industry, where it has become essential to experiment with developers and designers for example.</li>\r\n \t<li>Research into new business models and sharing best practices. The goal is to support companies in their development or creation. This has also led Ouest M\u00e9dialab to launch its incubator NMcube this year.</li>\r\n \t<li>Communication that places the spotlight on noteworthy innovation, especially on a local level - whether it\u2019s media, schools, start-ups or even communities.</li>\r\n \t<li>Open innovation in the form of short and midterm projects aimed at bringing actors closer together and creating collaborations around digital topics. This allows the media lab to highlight its unique characteristic as an open lab, which is not connected to any one media group in particular.</li>\r\n</ul>\r\n<h3>Building a community</h3>\r\nIn addition to a small team of four employees, Ouest M\u00e9dialab benefits from the voluntary support of its 130 members:\r\n<blockquote>\u201cThe time our members dedicate to the activities we organise represents the equivalent of at least two full-timers,\u201d says Ouest M\u00e9dialab Director Julien Kostr\u00e8che. \u201cThe cluster brings together most of the local media in the region - including Ouest-France, Le T\u00e9l\u00e9gramme, France 3, France Bleu, local television stations, community radio \u2013 but also the communities, content agencies, startups, journalism schools, communication programs, design and computer science schools.\u201d</blockquote>\r\nTo get to this point, it was necessary to find a common ground: the digital. Although not everybody starts at the same level, emphasises Julien: \u201cWhile some only just got started with video for example, others are part of companies where this has been the core of their profession for a long time already.\u201d\r\n\r\nThis led to the creation of the M\u00e9dialab Speed Training event, during which professionals that master certain digital tools share their skills and best practices with their peers. The power of such a community is also that it opens up access to feedback from members. As they voice their needs during the experimentations, they allow the media lab to rethink and refocus its strategy accordingly.\r\n<h3>Trust</h3>\r\nIt\u2019s not self-evident however for actors that are at times competing to share like this, says Julien:\r\n<blockquote>\u201cWhen you create a lab like that, people need time to get to know each other, start trusting each other, and accept to share their challenges with each other. Sometimes you have to accept to lay yourself bare on certain questions.\u201d</blockquote>\r\nIn response to this challenge, the Lab organised numerous workshops to allow everyone to exchange, propose their projects, and share their wishes, but also to get feedback. A great way to make everyone aware of the importance of this collective effort:\r\n<blockquote>\u201cToday people talk to us much more easily. They share their concerns with us and entrust us what they would like to do. It\u2019s then up to us to get the right people around the table, so they all get excited about working together.\u201d</blockquote>\r\n<h3>Developing a method</h3>\r\nIt all starts with an ideation phase during which the lab uses design-thinking methods focused on the user. During this phase, all of the professions are placed at the same level:\r\n<blockquote>\u201cWe don\u2019t go into a segmented production line right away. We start thinking about the project first, and everyone is allowed to leave his usual field. A computer scientist can express himself on an editorial dimension; a journalist on the interface. This creates unique conversations and takes the teams out of their comfort zones.\u201d</blockquote>\r\nNext, the teams create a model and a prototype that they test in order to confront themselves with the user. Then everybody goes back to his or her expertise. This first phase is really difficult, according to Julien, because not everyone speaks the same language:\r\n<blockquote>\u201cWe have to adapt to the themes that we\u2019re working on. Doing data journalism and creating an application for valorising archives do not necessarily require the same skills.\u201d</blockquote>\r\nAlthough it\u2019s a time-consuming method, it has proven itself indispensable. Going through these phases too quickly would mean reproducing the same old ways of producing content, with a fragmented transmission of information. This would result in projects that are incapable of going off the beating track.\r\n<h3>Adapting to constraints</h3>\r\nIn order to work with media you have to be able to identify and deal with some of the elements that are likely to hold them back in their innovation ambitions:\r\n<blockquote>\u201cWe started out with research labs initially. It was hard to get media on board that do not always have the time, the means, or this R&amp;D culture, and who want to get results within shorter timeframes.\u201d</blockquote>\r\nIn response to this, the Media lab team drew inspiration from hackathons and created Hyblabs. They bring together a hundred students from various disciplines (IT, design, media) into workgroups that tackle projects proposed by private media, community media and communication professionals. So far, 16 Hyblabs have taken place (3 to 4 a year), on topics ranging from data journalism and valorising archives to interactive storytelling and live coverage of events:\r\n<blockquote>\u201cYou have to the find people who are excited about these things, but you also have to trigger enthusiasm within organisations. In the beginning, people would take holidays or participated when they had a day off. We said to ourselves 'we have a problem'. So we kicked it up a few notches to convince the upper floors that they should free their teams for this.\u201d</blockquote>\r\nUnfortunately, the media economy doesn\u2019t always allow for this. It remains difficult to make people accept the experimental nature of a project in a tense financial environment where every investment has to lead to concrete results quickly:\r\n<blockquote>\u201cIt happens that media tell us \u2018one of our journalists will join for 3 days, but you have to guarantee us we\u2019ll get a result!\u2019 But when we experiment, we can\u2019t apply this kind of pressure \u2013 neither on the teams nor on the students that work together. You have to try to let go and accept the possibility of failure.\u201d</blockquote>\r\n<h3>A matter of good timing</h3>\r\nThe data journalism labs were one of the main successes of the Media Lab. Participants learned to collect, treat and visualise data to tell stories. The majority of the projects that came out of the hackathons have been published and well received by the audience. Some were even awarded and led to the creation of dedicated data teams, like those at T\u00e9l\u00e9gramme and Ouest-France:\r\n<blockquote>\u201cIn the case of T\u00e9l\u00e9gramme, the journalist came with an ambition: map the transformation of the city of Brest. He collects data from the relevant services, draws on what was done on the city of Berlin and comes to the HybLab where he meets a team of students from Polytech (computer), AGR (web design), and Audencia SciencesCom (media). In four long days, they manage to produce and publish the content online, asking inhabitants from Brest what they think about the transformation of the city. It\u2019s a hit and the project consolidates the decision of the press group management to create a dedicated data department with a full-time journalist.\"</blockquote>\r\nFor Julien Kostr\u00e8che, the crucial challenge is to find the right scale and the right timing:\r\n<blockquote>\u201cAnything around data worked pretty well, because everyone got into that around more or less the same moment. There was also a great timing with the opening up of public data (Open Data), which brought us a lot of material and it was a moment where extraordinary tools were launched almost every month to visualise this data.\u201d</blockquote>\r\nOuest Medialab has to constantly stay \u201con the edge\u201d, to find new playing fields that are in line with both the constraints of the sector and the local scale, as well as the maturity of technologies and their applications.\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n<img class=\"alignnone size-full wp-image-11703\" src=\"https://gami.wan-ifra.org/wp-content/uploads/2018/07/julien-e1533051589271.jpg\" alt=\"\" width=\"171\" height=\"231\" />\r\nJulien Kostr\u00e8che, Co-directeur, Ouest France Lab\r\nWeb: <a href=\"https://www.ouestmedialab.fr/\" target=\"_blank\" rel=\"noopener\">https://www.ouestmedialab.fr/</a>\r\nTwitter: <a href=\"https://twitter.com/jkostreche?lang=en\" target=\"_blank\" rel=\"noopener\">@jkostreche</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Ouest M\u00e9dialab: a cluster and independent media lab that supports the regional digital transition","post_link":"https://media-innovation.news/media-lab/ouest-medialab-a-cluster-and-independent-media-lab-that-supports-the-regional-digital-transition/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ouest M\u00e9dialab: a cluster and independent media lab that supports the regional digital transition\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2018/08/2HybLabRcitsInteractifsRennes2016-600x400-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"cluster, experiments, France, Hackathon, multidisciplinary, regional journalism, students","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1534260408:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Nantes, France","%_wpgmp_metabox_latitude%":"47.218371","%_wpgmp_metabox_longitude%":"-1.553621000000021","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"11717","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545292282,"payload":[{"id":10766},{"id":10704},{"id":10681}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"cluster, experiments, France, Hackathon, multidisciplinary, regional journalism, students"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11714,"infowindow_disable":false},{"source":"post","title":"RED/ACCION: both a formal innovation lab and daily experimentation in the newsroom","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"RED/ACCION: both a formal innovation lab and daily experimentation in the newsroom\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2018/07/DSC_9766-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">RED/ACCION: both a formal innovation lab and daily experimentation in the newsroom</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            It's important to have the space, the resources and the time to experiment and learn on a daily basis in the newsroom. \"We don\u2019t want the Maker Lab to be the only place where experimentation and learning take place\", says Chani Guyot. \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/red-accion-both-a-formal-innovation-lab-and-daily-experimentation-in-the-newsroom/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"It's important to have the space, the resources and the time to experiment and learn on a daily basis in the newsroom. \"We don\u2019t want the Maker Lab to be the only place where experimentation and learning take place\", says Chani Guyot. ","address":"Buenos Aires, Argentina","location":{"lat":"-34.60368440000001","lng":"-58.381559100000004","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/red-accion-both-a-formal-innovation-lab-and-daily-experimentation-in-the-newsroom/","zoom":2,"extra_fields":{"post_excerpt":"It's important to have the space, the resources and the time to experiment and learn on a daily basis in the newsroom. \"We don\u2019t want the Maker Lab to be the only place where experimentation and learning take place\", says Chani Guyot. ","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>RED/ACCION: both a formal innovation lab and daily experimentation in the newsroom</h1>\r\n<strong>It's important to have the space, the resources and the time to experiment and learn on a daily basis in the newsroom. \"We don\u2019t want the Maker Lab to be the only place where experimentation and learning take place\", says Chani Guyot.\r\n</strong>\r\n\r\nHaving spent 20 years as a journalist and editor-in-chief at La Nacion, Chani Guyot decided he would like to do something else in the next 20 years of his career. In April 2018 he launched RED/ACCION, after having collected 1,5 million dollars in initial funding in only two months.\r\n\r\nThe digital pure player combines a 12 people newsroom that\u2019s exploring different ways to report mobile stories with a formal innovation lab:\r\n<blockquote>\u201cWe don\u2019t want the Maker Lab to be the only place where experimentation and learning take place. We\u2019re very serious about having the space, the resources and the time to experiment and learn on a daily basis in our newsroom, even if we don\u2019t put the name Lab on it.\u201d</blockquote>\r\n<h3>Maker Lab with students</h3>\r\nChani teamed up with Juan Mascardi, one of the best journalists and teachers in Argentina, to develop a model of the Maker Lab that is very focused on students:\r\n<blockquote>\u201cBecause we want young men and women in their early twenties to have the tools, the space, the support and the training to really experiment.\u201d</blockquote>\r\nTheir first project will be around Inclusive Cities, in Rosario, the third city of Argentina, well known for its education and cultural life. During a three-month program, students get hands-on training, tools, and editorial support to report on the topic of \u2018inclusive cities\u2019, and RED/ACCION publishes their stories:\r\n<blockquote>\u201cWe focus on how to tell local stories with your phone and for your phone. So that\u2019s the scope of the lab, mainly, with the use of video, data, and transmedia with some tools. It\u2019s a very small scope because we want to move forward quickly and that\u2019s the way to do that.\u201d</blockquote>\r\nAs they only just started selecting students from the 4 journalism schools in Rosario, it\u2019s too soon to say anything in terms of results. But after this pilot in Argentina\u2019s third largest city, the idea is to roll out the format to other places in the country, around the topics that are relevant to each city.\r\n<h3>Newsroom experiments</h3>\r\nThe Lab is part of a digital pure player that Chani launched only last April. He stresses that experimentation and learning shouldn't just happen in the lab. On a daily basis, the newsroom is experimenting with new formats and new ways of working, especially around conversational platforms:\r\n<blockquote>\u201cWe think that conversational platforms are a big deal and will be a bigger deal in the future. In Argentina we have 1,2 cell phones per person and one of the highest rates of active Whatsapp accounts. So the day Whatsapp opens its API we want to be ready.\u201d</blockquote>\r\nAs part of the experimentation with conversational platforms, RED/ACCION published a number of interviews that were made on Whatsapp and published as a collection of screenshots:\r\n<blockquote>\u201cWhen you read that on your phone you feel like you\u2019re sneaking into a private conversation. Because that\u2019s the usual usage of Whatsapp, and the tone and style are preserved.\u201d</blockquote>\r\n&nbsp;\r\n\r\n<img class=\"aligncenter wp-image-11703 size-large\" src=\"https://media-innovation.news/wp-content/uploads/2018/07/Screen-Shot-2018-07-24-at-10.28.02-1024x566.png\" alt=\"\" width=\"1024\" height=\"566\" />\r\n\r\nTo take this a step further, they tried to use Al Jazeera\u2019s open Interview API SJ, but the user experience was a little clumsy. For another story about bees, a bee would die when you touched it on your screen. This element was eventually taken out, because it didn\u2019t suit the spirit of the story. But those \u2018mistakes\u2019 are part of the process, according to Chani:\r\n<blockquote>\u201cThe interesting thing I think is that we published, saying to our readers: we are experimenting - we want to learn \u2013 what do you think? And we are receiving a lot of feedback.\u201d</blockquote>\r\n<h3>Training your muscles</h3>\r\n<blockquote>\u201cThe most interesting things we learn doing Instagram stories. We do quizzes, and almost everybody fails. We\u2019re breaking open common sense by showing the difference between what you think the story is and what it actually is.\u201d</blockquote>\r\nSome of these projects don\u2019t lead to any direct results \u2013even though most of them increase audience engagement with the project\u2013, you're still training muscles that you can then use for projects that you don't know now might come along in 6 months or so, says Chani:\r\n<blockquote>\u201cLike when you're doing sports and suddenly discover you hurt in places you didn't even know you had muscles.\u201d</blockquote>\r\n<h3>Fast, faster, fast</h3>\r\nGoing from a large legacy media company to starting an online outlet from scratch, Chani has been mostly surprised by the speed at which things can move from decision to execution. Recently, for example, when a friend called him about publishing a new podcast series:\r\n<blockquote>\u201cShe called me in the morning to ask if we wanted to partner on it. 24 hours later we approved the idea, got the technical requirements in place and published the first story.\u201d</blockquote>\r\nThere\u2019s no question for Chani that La Nacion is an exquisite company, but the beauty of being small is that the reward doesn\u2019t have to be enormous:\r\n<blockquote>\u201cI was leading a newsroom of 300 people and even though we had more or less unlimited resources, you need to know the size of the impact when you move forward with these kinds of projects. In our case, as we are new and small, the risk is lower.\u201d</blockquote>\r\n<h3>Nurturing small ideas</h3>\r\nBeing small gives you advantages in terms of going faster and deeper. In a big structure small ideas are usually dropped too fast unless they prove that they have the potential of becoming big ideas. It\u2019s easier to breed small ideas turning into big ideas in a small structure than in a big one says Chani:\r\n<blockquote>\u201cI love this idea that a big idea, a very big idea, it\u2019s really just a small idea that finds someone courageous to protect it through the breeding phases. And of course, once they become big ideas, they are adopted by big media. That\u2019s beautiful.\u201d\r\n\r\n&nbsp;</blockquote>\r\nCONTACT POINT\r\n<img class=\"alignnone size-full wp-image-11695\" src=\"https://media-innovation.news/wp-content/uploads/2018/07/chani.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\nChani Guyot, founder, RED/ACCION\r\nWeb: <a href=\"https://redaccion.com.ar/lab-de-redaccion/\" target=\"_blank\" rel=\"noopener\">https://redaccion.com.ar/lab-de-redaccion/</a>\r\nTwitter: <a href=\"https://twitter.com/carlosguyot\" target=\"_blank\" rel=\"noopener\">@carlosguyot</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"RED/ACCION: both a formal innovation lab and daily experimentation in the newsroom","post_link":"https://media-innovation.news/media-lab/red-accion-both-a-formal-innovation-lab-and-daily-experimentation-in-the-newsroom/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"RED/ACCION: both a formal innovation lab and daily experimentation in the newsroom\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2018/07/DSC_9766-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"applications, Argentina, digital media, mobile journalism, students","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1533050790:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Buenos Aires, Argentina","%_wpgmp_metabox_latitude%":"-34.60368440000001","%_wpgmp_metabox_longitude%":"-58.381559100000004","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_primary_category%":"142","%_kleo_title_checkbox%":"1","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545437321,"payload":[{"id":11235},{"id":10155},{"id":11225}]}},"%_thumbnail_id%":"11707","%_wp_old_date%":"2018-07-12","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"applications, Argentina, digital media, mobile journalism, students"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11691,"infowindow_disable":false},{"source":"post","title":"&#8220;Stick to the method and do it by the book, at least in the beginning&#8221;","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"&#8220;Stick to the method and do it by the book, at least in the beginning&#8221;\" width=\"300\" height=\"181\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/Screen-Shot-2018-04-18-at-10.10.37-300x181.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">&#8220;Stick to the method and do it by the book, at least in the beginning&#8221;</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Five questions to Clemens Prerovsky (CDO) about ongoing projects, lessons learned and best practices at the APA-medialab.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/stick-method-book-least-beginning/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Five questions to Clemens Prerovsky (CDO) about ongoing projects, lessons learned and best practices at the APA-medialab.","address":"Vienna, Austria","location":{"lat":"48.2081743","lng":"16.37381890000006","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/stick-method-book-least-beginning/","zoom":2,"extra_fields":{"post_excerpt":"Five questions to Clemens Prerovsky (CDO) about ongoing projects, lessons learned and best practices at the APA-medialab.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>\"Stick to the method and do it by the book, at least in the beginning\"</h1>\r\n<strong>Five questions to Clemens Prerovsky (CDO) about ongoing projects, lessons learned and best practices at the APA-medialab.</strong>\r\n\r\nIn January 2017, the APA-medialab was <a href=\"https://media-innovation.news/media-lab/apa-medialab-innovating-journalism-through-prototypes-and-trend-research/\" target=\"_blank\" rel=\"noopener\">created</a> to improve the time to market of their products and to break down silos that existed within the news agency in terms of approaching topics of innovation. In the meantime, the Head of the lab left to start a company with his brother, and Clemens Prerovsky took over.\r\n<h3>1. What are you working on right now?</h3>\r\nWe have a lot of stuff going on right now. The thing we\u2019re currently working on is a really playful one. We often have to show something at events that we're attending. So we\u2019re working on an application that uses face detection and interprets your emotions using open source software. Based on that we automatically generate a social media message that you can then post.\r\n\r\nSo you can write a post with your face!\r\n\r\nBut it\u2019s not only fun. It also incorporates technologies that we might use in the future, like emotion detection, face detection, automated text generation and Artifical Intelligence. And that\u2019s where we\u2019re headed.\r\n\r\nIn May, we will have our first full-fledged machine-learning project, which I\u2019m really excited about. We will categorise text and news, so customers can order all the news articles that are about them to be sent to them every day. Right now, somebody is reading through 300 articles every morning and we hope to automate that to some extent. I\u2019m confident that we can do that with high precision. As a news agency, we have years and years of data that we can use to train a Neural Network to do that.\r\n<h3>2. What changed since the lab was created in January 2017?</h3>\r\nSomething will probably change very soon, namely the way we set up the road map for the lab. So far, everybody could book their time with us and we try to balance all the requests and ideas from all parts of the company: from different departments, from the CEOs and some from the lab itself. We collect all of those requests and turn them into a road map. It\u2019s a rather complicated process and the proposals are too often focused on the now.\r\n\r\nI would like to change that pretty drastically, so that the lab provides all of the topics for the future roadmap. Since we also have a research focus and want to look at the trends that will impact us until 2025. At the moment, this is missing a bit from our roadmap, except the AI stuff. And I would like to focus more on the future. Decide where the company wants to be in a few years and then work towards that.\r\n<h3>3. What is your main lesson learned?</h3>\r\nOne thing we\u2019ve learned is that participating in a Design Sprint during one week is perceived as a very high commitment. Which is understandable, because you\u2019re really taken off the job for one week. But no one seems to realise that it would have otherwise taken half a year to develop the same project.\r\n\r\nThe other thing is that the Google Design Sprint is focused on testing on Friday, but that\u2019s super hard to do in Austria. People usually try to get their stuff done on Friday morning, so they can leave early. Which means there is no room for testing with us.\r\n\r\nThat\u2019s why we changed up the sprint a bit. We spread it out, so the developers can continue coding on Friday and we do the user testing the following week. This works really well against the fear of high commitment and the developers have more time to do their work.\r\n\r\nWe also tried a very short sprint once, which lasted only 2,5 days. The owner was very happy witht he results, but I wasn\u2019t. I felt the ideas were too much aligned with each other, because we lacked this phase of creative input in the beginning. That just wasn\u2019t enough. We basically ended up with seven sketches of the same product.\r\n<h3>4. What has been your \u2018best failure\u2019?</h3>\r\nA few months ago, we did a sprint on voice-enabled media with the aim to think of new ways to use voice in media. The only thing you can really do at the moment is ask Alexa for news updates. You get a news update that she reads out, and in the morning it\u2019s the same as in the evening. So we wanted to work try and come up with new ideas for voice-enabled media.\r\n\r\nEverything was going really well; we aligned the sprint with the launch of Google home in Germany, so we had the Google device and we were prepared really well. But then it turned out that although Google home works in German, it doesn\u2019t have a German API. So we couldn\u2019t do anything with the device. It was totally pointless. Nobody could develop an app in German. So that was kind of a failure.\r\n\r\nAlternatively we used Alexa, but Alexa has terrible voice capabilities. We were not impressed with that. So in the end we used the browser\u2019s capabilities for voice-recognition. Which are not as good, but they were there and they were free.\r\n\r\nAnd we had so much fun! Although Alexa failed all the time, the cool thing is that the design sprint method allows you to accommodate to the situation, even when things go really wrong. We were not stuck to the Google device. We were able to work around it and still do the sprint.\r\n<h3>5. What advice would you give to someone looking to start a media innovation lab?</h3>\r\nStick to the method and do it by the book, at least in the beginning. Things start to fall apart quickly enough, but what I see a lot of times is that people start changing up the method before they even tried to do it correctly once and see how it works.\r\n\r\nThat was one of the first things I wanted to try when I became head of the APA-medialab, to really do it by the book. We didn\u2019t use the map for example, because people didn\u2019t like it. But it actually brought some really nice insights.\r\n\r\nEven though we changed the time frames, I don\u2019t like changing up those methods too much. The agile methods are so focused that taking something out means you\u2019ll miss an important part of the process. It\u2019s like driving a three-wheeled car.\r\n\r\nWhat you could do is take parts of the method and use them in different contexts. Every piece is there to solve a specific problem, in a specific stage of generating ideas. And of course you can reuse them in other situations.\r\n\r\n--\r\n\r\n<em>APA Editor-in-Chief Michael Lang will be at the <a href=\"https://events.wan-ifra.org/events/70th-world-news-media-congress-25th-world-editors-forum/programme\" target=\"_blank\" rel=\"noopener\">World News Media Congress</a> to talk about his experiences working with the Lab. Join us for the LabLunch on Friday 8 June. </em>\r\n\r\n--\r\n\r\n<em>Also read the previous article on the APA-medialab: <a href=\"https://media-innovation.news/media-lab/apa-medialab-innovating-journalism-through-prototypes-and-trend-research/\" target=\"_blank\" rel=\"noopener\">Innovating journalism through prototypes and trend research</a>.</em>\r\n\r\n--\r\n\r\nCONTACT POINT\r\n<img class=\"alignnone size-full wp-image-11577\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/Prerovsky_Clemens_PR_CMYK.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\nClemens Prerovsky, CDO, APA-medialab\r\nWeb: <a href=\"https://medialab.apa.at/\" target=\"_blank\" rel=\"noopener\">https://medialab.apa.at/</a>\r\nTwitter: <a href=\"https://twitter.com/blacktarmac\" target=\"_blank\" rel=\"noopener\">@blacktarmac \u200f</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"&#8220;Stick to the method and do it by the book, at least in the beginning&#8221;","post_link":"https://media-innovation.news/media-lab/stick-method-book-least-beginning/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"&#8220;Stick to the method and do it by the book, at least in the beginning&#8221;\" width=\"300\" height=\"181\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/Screen-Shot-2018-04-18-at-10.10.37-300x181.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"AI, Austria, automation, design sprint, machine learning","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1535523338:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Vienna, Austria","%_wpgmp_metabox_latitude%":"48.2081743","%_wpgmp_metabox_longitude%":"16.37381890000006","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_primary_category%":"","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545291647,"payload":[{"id":11714},{"id":10651},{"id":10704}]}},"%_thumbnail_id%":"11581","%_yoast_wpseo_focuskw_text_input%":"APA-medialab","%_yoast_wpseo_focuskw%":"APA-medialab","%_yoast_wpseo_linkdex%":"63","%_publicize_pending%":"1","%_wp_old_date%":"2018-04-18","%sharing_disabled%":"1","%switch_like_status%":"0","%_show_author_inthis_post%":"inthis_post","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"AI, Austria, automation, design sprint, machine learning"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11574,"infowindow_disable":false},{"source":"post","title":"FranceTV Lab: testing new tools in the lab first to facilitate adoption in the newsroom","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"FranceTV Lab: testing new tools in the lab first to facilitate adoption in the newsroom\" width=\"300\" height=\"165\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/VR-applications-300x165.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">FranceTV Lab: testing new tools in the lab first to facilitate adoption in the newsroom</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            In the lab, FranceTV tests new tools and learns how to use them before introducing them to the newsroom. A way to spread the digital culture among journalists, who tend to be conservative and not always open to new ways of working.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/francetv-lab-testing-new-tools-lab-first-facilitate-adoption-newsroom/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"In the lab, FranceTV tests new tools and learns how to use them before introducing them to the newsroom. A way to spread the digital culture among journalists, who tend to be conservative and not always open to new ways of working.","address":"7 Esplanade Henri France, 75015 Paris, France","location":{"lat":"48.8393488","lng":"2.2711252999999942","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/francetv-lab-testing-new-tools-lab-first-facilitate-adoption-newsroom/","zoom":2,"extra_fields":{"post_excerpt":"In the lab, FranceTV tests new tools and learns how to use them before introducing them to the newsroom. A way to spread the digital culture among journalists, who tend to be conservative and not always open to new ways of working.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>FranceTV Lab: testing new tools in the lab first to facilitate adoption in the newsroom</h3>\r\n<strong>In the lab, FranceTV tests new tools and learns how to use them before introducing them to the newsroom. A way to spread the digital culture among journalists, who tend to be conservative and not always open to new ways of working.</strong>\r\n\r\nFrance T\u00e9l\u00e9visions is the French public broadcasting organisation based in Paris, with over 10 000 employees. Grown out of a small innovation department that existed within France T\u00e9l\u00e9visions since 2010, the media lab was created in 2016 with a triple mission:\r\n<ul>\r\n\t<li>Test new tools that could be useful for the newsroom and for developing audiences;</li>\r\n\t<li>Connect television and online journalists, developers, designers, and start-ups;</li>\r\n\t<li>And help the newsroom become more accustomed to digital challenges through training, knowledge sharing and best practices.</li>\r\n</ul>\r\nA lab needed to be created to get closer to the newsroom and to have an actual team:\r\n<blockquote>\u201cI\u2019m most proud of how the lab is working with the newsroom on the one hand and with developers and designers on the other hand,\" says Eric Scherer,\u00a0Director of the Digital Innovation department and Head of FranceTV Lab. \"The lab is part of the newsroom. It\u2019s a real beginning of co-working between engineers and designers, and journalists and reporters.\u201d</blockquote>\r\n<h3>Testing tools</h3>\r\nAs the lab doesn\u2019t have any developers itself, they work closely together with the innovation department to develop the tools. The team of three journalists and trainees tests tools and learns how to use them before deciding whether to introduce them to the journalists:\r\n<blockquote>\u201cWe try and test tools. If it\u2019s a good tool we will present it to the newsroom. If they\u2019re interested they buy it. If not, we throw it away,\u201d explains Eric Scherer.</blockquote>\r\nEven when the tools are not adopted by the journalists, the lab\u2019s work remains useful. It helps France T\u00e9l\u00e9visions to stay aware of the innovations in the audiovisual sector, sustain a dialogue with the start-up ecosystem and become accultured to the digital challenges that the media need to face today.\r\n\r\nHowever, Eric doesn\u2019t see that it has become any easier to introduce new tools to the newsroom compared to 2016, when they first started doing this: \u201cIt\u2019s still very difficult, because journalists are always in a rush; they have no time to try new things.\u201d\r\n\r\nAlthough it depends a lot on the individual journalists:\r\n<blockquote>\u201cIt depends on the digital background of every journalist, if they like it, if they\u2019re young. It\u2019s not connected to specific departments. We just have to know those individuals and let them be our ambassadors in the newsroom.\u201d</blockquote>\r\n<h3>New formats</h3>\r\nTrying to create new formats and tools to reconnect with audiences; that\u2019s the goal. Examples of projects include the use of <a href=\"http://www.francetelevisions.fr/lab/power-bi-l-information-decryptee-sous-vos-yeux\" target=\"_blank\" rel=\"noopener\">datavisualisation technologies</a> during the electoral nights on the news channel franceinfo, in partnership with Microsoft, and a serious game app called <a href=\"http://www.francetelevisions.fr/lab/ma-campagne-information-gamifiee\" target=\"_blank\" rel=\"noopener\">Ma Campagne</a>, developed with journalism and design students, that reached 35.000 downloads. As the lab doesn\u2019t have a dedicated budget, it works with partners inside and outside the company to develop these projects.\r\n<h3><img class=\"aligncenter wp-image-11602\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/PowerBI-project-300x165.jpg\" alt=\"\" width=\"740\" height=\"407\" /></h3>\r\nFor example, with the Presidential elections in France last year, the lab worked together closely with the newsroom on a Virtual Reality project. In this <a href=\"http://www.francetelevisions.fr/lab/presidentielle-2017-vr-l-information-immersive\" target=\"_blank\" rel=\"noopener\">VR application</a>, all candidates had their own avatars that allowed voters to \u2018meet\u2019 the candidates, discover their programmes and have access to all of their media appearances. Users of the app could also take a virtual tour of the Palais de l\u2019Elys\u00e9e:\r\n<blockquote>\u201cThe immersive technologies created a setting for a relationship where the user was an actor in the meeting and could get very close to generally unapproachable politicians.\u201d</blockquote>\r\n<h3>Learning and training</h3>\r\nUnfortunately, not a lot of people in France were aware of the application, so few people actually used it. On the bright side, the FranceTV Lab team learned a lot about VR technology:\r\n<blockquote>\u201cThe app reached a quite restricted audience compared to our other TV and digital contents on politics. But we still reached our goal, which was to show that France T\u00e9l\u00e9visions is able to offer innovative news formats.\u201d</blockquote>\r\nDrawing on this experience, the team keeps exploring the editorial applications of new technologies and is now training journalists who want to work with 360\u00b0 video; teaching them the rules and best practices of this format.\r\n\r\nThat expertise is also useful for other media companies. When the lab learned how to use Snapchat to produce media content for example, they were not only able to train journalists at France T\u00e9l\u00e9visions, but also elsewhere in Paris and France on how best to use the platform.\r\n<h3>Bridges inside the company</h3>\r\nBeing the head of both the Digital Innovation department and the media lab makes it easier to build bridges between different parts of the organisation, says Eric Scherer:\r\n<blockquote>\u201cIt\u2019s exactly the right opportunity to build bridges between the digital and the rest of the company, which is very difficult. Digital is always separate and it\u2019s 1 km away from the office. So this bridge is a concrete bridge between the digital and one of the traditional departments, which is the newsroom.\u201d</blockquote>\r\nHowever, the lab\u2019s work seems more visible outside of the company than internally. While their <a href=\"https://www.meta-media.fr/\" target=\"_blank\" rel=\"noopener\">meta-media blog</a> gets 50.000 views on average per month, most France T\u00e9l\u00e9visions journalists do not really read it:\r\n<blockquote>\u201cIn French we say \u2018nul n\u2019est proph\u00e8te en son pays\u2019. We\u2019ll start sending out a newsletter soon, and we have to organise more physical meetings at different news departments within our company. We are not doing it enough. Going forward, we will be more inside-looking, to share more with the newsroom.\u201d\r\n\r\n&nbsp;</blockquote>\r\nCONTACT POINT\r\n<img class=\"alignnone size-full wp-image-11605\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/eric-scherer.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\nEric Scherer, Director of the Digital Innovation department and Head of FranceTV Lab, France T\u00e9l\u00e9visions\r\nWeb: <a href=\"http://www.francetelevisions.fr/lab\" target=\"_blank\" rel=\"noopener\">http://www.francetelevisions.fr/lab</a>\r\nTwitter: <a href=\"https://twitter.com/EricScherer\" target=\"_blank\" rel=\"noopener\">@EricScherer</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"FranceTV Lab: testing new tools in the lab first to facilitate adoption in the newsroom","post_link":"https://media-innovation.news/media-lab/francetv-lab-testing-new-tools-lab-first-facilitate-adoption-newsroom/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"FranceTV Lab: testing new tools in the lab first to facilitate adoption in the newsroom\" width=\"300\" height=\"165\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/VR-applications-300x165.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"France, Immersive, industry collaboration, tools, training and education","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1570114385:931","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"7 Esplanade Henri France, 75015 Paris, France","%_wpgmp_metabox_latitude%":"48.8393488","%_wpgmp_metabox_longitude%":"2.2711252999999942","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%_kleo_title_checkbox%":"1","%_yoast_wpseo_focuskw_text_input%":"testing","%_yoast_wpseo_focuskw%":"testing","%_yoast_wpseo_linkdex%":"68","%_thumbnail_id%":"11603","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1544755206,"payload":[{"id":11235},{"id":11691},{"id":10704}]}},"%_publicize_pending%":"1","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"France, Immersive, industry collaboration, tools, training and education"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11568,"infowindow_disable":false},{"source":"post","title":"Media and Democracy: research and innovation to strengthen journalism, public discourse and democracy","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Media and Democracy: research and innovation to strengthen journalism, public discourse and democracy\" width=\"300\" height=\"170\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/Media-democracy-medialab-300x170.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Media and Democracy: research and innovation to strengthen journalism, public discourse and democracy</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Media organisations, academics and public institutions work together on experimental innovation and research at Lindholmen Science Park.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/media-and-democracy-lindholmen/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Media organisations, academics and public institutions work together on experimental innovation and research at Lindholmen Science Park.","address":"Lindholmen, Gothenburg, Sweden","location":{"lat":"57.7077599","lng":"11.938286500000004","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/media-and-democracy-lindholmen/","zoom":2,"extra_fields":{"post_excerpt":"Media organisations, academics and public institutions work together on experimental innovation and research at Lindholmen Science Park.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Media and Democracy: research and innovation to strengthen journalism, public discourse and democracy</h1>\r\n<strong>Media organisations, academics and public institutions work together on experimental innovation and research at Lindholmen Science Park.</strong>\r\n\r\nIn the summer of 2017, the Media and Democracy research and innovation programme was launched to facilitate collaboration on experimental projects between universities and media companies in Sweden. Its core mission is to initiate, finance and run research and innovation projects that provide new knowledge and tools for journalism and civil dialog.\r\n\r\nHead of the programme Martin Holmberg and his colleague Jonathan Falck bring together different actors and share new insights about the ways in which innovation influences media and democracy through reports and seminars. Built on the ideals of open innovation, citizens are welcome to participate in their activities as well.\r\n\r\nWhile media companies don\u2019t collaborate as much as they could or should, academics are increasingly looking to get access to news organisations for making their research more relevant to practice. According to Martin, Lindholmen Science Park provides a neutral space where they can meet physically and mentally to develop innovative ideas together:\r\n<blockquote>\u201cWe are a non-profit company. Our mission is to get benefits to society and get the actors to succeed. No one can be afraid of Lindholmen, because we have the mission just to do nice things for all the people in our network.\"</blockquote>\r\n<h3>Reinforcing local democracy</h3>\r\nSwedish local newspaper Bor\u00e5s Tidning, RISE Interactive and S\u00f6dert\u00f6rn University are part of one of the Lab\u2019s <a href=\"https://medierochdemokrati.lindholmen.se/en/news/media-democracy-launches-test-editorial-team-new-local-journalism\" target=\"_blank\" rel=\"noopener\">first projects</a>. In an attempt to strengthen journalism at the local level, the project runs an experiment with topics and formats interesting for younger audiences:\r\n<blockquote>\u201cThe paper has employed four people between 25 and 35 years old that work in the newspaper; some are journalists, some are not. They don\u2019t have to listen to the editors like the other journalists, so we can compare the difference. That\u2019s the way we typically want to work, through experimentation.\u201d</blockquote>\r\n<img class=\"aligncenter wp-image-11559 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/Experimental-newsroom-at-Bora\u030as-Tidning-e1523011691215.jpg\" alt=\"\" width=\"927\" height=\"700\" />\r\n\r\nThis kind of project is one of the ways in which Lindholmen is addressing the challenge of developing the local society in a new media landscape. Even ten years ago, discussions still happened primarily on local platforms; now they mostly take place on social media. That raises important issues for media and democracy, says Martin:\r\n<blockquote>\u201cHow can we make sure that in the future you can develop the public discussion in the local society, in the sense that people share enough important information to be able to have prospective, democratic discussions together? On social media you don\u2019t share the same information, so developing the local society becomes a challenge.\u201d</blockquote>\r\n<h3>New media behaviour</h3>\r\nAs society changes, so do the ways in which people interact with media:\r\n<blockquote>\u201cI can see my wife and I for example live very differently than my parents. I live in a small town north of Gothenberg, we take the commuting train, so we can\u2019t spend time on the same things my parents did.\r\n\r\nMy parents worked within 10 minutes by bicycle from our home. They picked up the newspaper in the morning and in the evening. I remember my father sometimes came home for lunch and then biked back.\r\n\r\nI don\u2019t know any people of my age who do this.\u201d</blockquote>\r\nWith every project, the goal is to find out how people act, what is important for them, and possibly to develop some technologies to support that. But technology is not in the middle; the starting point is what people need.\r\n<h3>Bottom-up problem finding</h3>\r\nIn the same way, Media and Democracy decides what topics to tackle by asking its network what their main challenges are. Four times a year, they invite people with different skills and experiences to round tables, including scholars, media companies and citizens:\r\n<blockquote>\u201cWe discuss what kinds of challenges they see, what projects would be perfect to find new knowledge about these challenges, what experimental ways there are to develop new knowledge, and who in the room would want to participate in such a project or has ideas about who we should talk to.\u201d</blockquote>\r\nIt\u2019s especially remarkable how different actors often have very similar issues on their minds, says Martin. The role of Media and Democracy is to collect this input and turn it into concrete projects:\r\n<blockquote>\u201cAfter these round tables they return to their normal day work, but we have the time and opportunity to think about how we could do this, what partners we could invite, where we could find funding. So we do a lot of work in the background to get these projects up and running.\u201d</blockquote>\r\nBasic funding for the projects comes from the Region V\u00e4stra G\u00f6taland, but the initiative is also supported by commercial media, public broadcasting companies and key media players in the Swedish academic community.\r\n<h3>An innovative environment</h3>\r\nThe Lindholmen Science Park emerged only recently in the old harbor of Gothenberg. When the ship building companies closed their doors in the 1970s, the Science Park successively took their place and attracted companies in the IT, auto mobility and media sectors. Science Parks in Sweden are generally aimed at businesses, but Lindholmen is connecting technology and creativity. They aim to bring together different perspectives and different skills to find new solutions:\r\n<blockquote>\u201cThe game incubator launches games that are being downloaded and generate business. Half of all films in Sweden are in some way connected to the film cluster at Lindholmen Science Park. And several companies and communities use the visualisation technology and environment here, including to strengthen democracy.\r\n\r\nThere might be possibilities to combine some of the expertise and the technologies present in the cluster for media innovation.\u201d</blockquote>\r\nAlthough the Media and Democracy programme is still very young, Martin hopes its success will be similar to that of the \u2018older\u2019 labs at Lindholmen Science Park.\r\n\r\nCONTACT POINT\r\n<img class=\"alignnone size-full wp-image-11554\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/MartinHomlberg-2016-webb.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\nMartin Holmberg, Head of Media &amp; Democracy, Lindholmen Science Park\r\nWeb: <a href=\"https://medierochdemokrati.lindholmen.se/en\" target=\"_blank\" rel=\"noopener\">https://medierochdemokrati.lindholmen.se/en</a>\r\nTwitter: <a href=\"https://twitter.com/Lindholmen\" target=\"_blank\" rel=\"noopener\">@Lindholmen</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Media and Democracy: research and innovation to strengthen journalism, public discourse and democracy","post_link":"https://media-innovation.news/media-lab/media-and-democracy-lindholmen/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Media and Democracy: research and innovation to strengthen journalism, public discourse and democracy\" width=\"300\" height=\"170\" src=\"https://media-innovation.news/wp-content/uploads/2018/04/Media-democracy-medialab-300x170.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic collaboration, experiments, industry collaboration, local journalism, Sweden, young audiences","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1526999738:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Lindholmen, Gothenburg, Sweden","%_wpgmp_metabox_latitude%":"57.7077599","%_wpgmp_metabox_longitude%":"11.938286500000004","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_primary_category%":"69","%_thumbnail_id%":"11556","%_kleo_title_checkbox%":"1","%_yoast_wpseo_focuskw_text_input%":"democracy","%_yoast_wpseo_focuskw%":"democracy","%_yoast_wpseo_linkdex%":"71","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1544892994,"payload":[{"id":11362},{"id":10645},{"id":10673}]}},"%_publicize_pending%":"1","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic collaboration, experiments, industry collaboration, local journalism, Sweden, young audiences"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11553,"infowindow_disable":false},{"source":"post","title":"Next Media Accelerator: the German Press Agency accelerating media and marketing start-ups in Hamburg","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Next Media Accelerator: the German Press Agency accelerating media and marketing start-ups in Hamburg\" width=\"300\" height=\"157\" src=\"https://media-innovation.news/wp-content/uploads/2018/02/Header-300x157.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Next Media Accelerator: the German Press Agency accelerating media and marketing start-ups in Hamburg</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            NMA aims to offer media and marketing start-ups a place to succeed and provide its 190 stakeholders with strategies for managing the digital transformation at hand. \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/next-media-accelerator-german-press-agency-accelerating-media-marketing-start-ups-hamburg/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"NMA aims to offer media and marketing start-ups a place to succeed and provide its 190 stakeholders with strategies for managing the digital transformation at hand. ","address":"Hamburg, Germany","location":{"lat":"53.5510846","lng":"9.993681899999956","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/next-media-accelerator-german-press-agency-accelerating-media-marketing-start-ups-hamburg/","zoom":2,"extra_fields":{"post_excerpt":"NMA aims to offer media and marketing start-ups a place to succeed and provide its 190 stakeholders with strategies for managing the digital transformation at hand. ","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Next Media Accelerator: the German Press Agency accelerating media and marketing start-ups in Hamburg</h1>\r\n<strong>\u201cBut working with start-ups can never replace doing innovation within your own company; you need both,\u201d says Meinolf Ellers (dpa).</strong>\r\n\r\nNext Media Accelerator is an independent industry accelerator initiated by the German Press Agency (dpa). Founded in 2015, it aims to offer media and marketing start-ups a place to succeed and provide its 190 stakeholders with strategies for managing the digital transformation at hand.\r\n\r\nAs dpa is a media company itself as well, they are not only the initiator of the Next Media Accelerator, but also work with their start-ups and participate in test-runs to find solutions themselves:\r\n<blockquote>\u201cNMA may be the most radical and foolish initiative we\u2019ve ever taken in terms of digital transformation at dpa,\u201d says Meinolf Ellers, managing partner of the Next Media Accelerator and in charge of digital operations at dpa for the last 23 years. \u201cBut working with start-ups can never replace doing innovation within your own company; you need both.\u201d</blockquote>\r\n<h3>Scalable tech and business models</h3>\r\nThe idea for the Next Media Accelerator came during a trip to the United States where Meinolf met Matter VC, a media start-up accelerator with offices in San Francisco and New York City:\r\n<blockquote>\u201cThey were a little bit a blueprint for us. When we visited Silicon Valley in 2013 and we came across this initiative we wondered why nothing like this existed in Europe.\u201d</blockquote>\r\nMatter VC supports initiatives around storytelling and the future of journalism, and initial funding came from the Knight Foundation. The Next Media Accelerator would rather focus on scalable tech and business models:\r\n<blockquote>\u201cWe don\u2019t need innovation in storytelling in Europe. On the other hand, there is a big need for scalable technology and sustainable business models.\u201d</blockquote>\r\n<h3>Media companies as investors</h3>\r\nDifferent objectives call for different sources of financing. So it made more sense for the Next Media Accelerator to set up a launching program than to apply for funds.\r\n\r\nTen investors from the German media industry - including Axel Springer, Die Zeit and Der Spiegel - each paid 200k, financing the first two years of the NMA. In return, NMA guaranteed them to build a portfolio of 20 companies offering media and marketing solutions. They succeeded and closed this round last summer:\r\n<blockquote>\u201cSince the first of July 2017 we are in the next round, NMA 2. We have extended the fundraising period until the end of March 2018. Currently we are 25 investors and we have raised 7 Million so far, but we hope to get a little bit closer to 8 Million. And we'll use this money to run the program until 2022, so for five years this time instead of two.\u201d</blockquote>\r\nAlthough there are KPIs for the start-ups, the investors seem most interested in the contribution the programme makes to their digital transformation:\r\n<blockquote>\u201cSome of our investors, especially those that were already our partners in the first round, decided to join NMA2 and even with a higher investment. Not because it's an investment that means a lot of profit for them in the long run, but because it's a strong tool for their transformation strategy. It's like an outsourced R&amp;D unit.\u201d</blockquote>\r\n<h3>The freedom to pivot</h3>\r\nBy positioning itself an independent industry accelerator, the NMA aims to distinguish itself from corporate accelerators:\r\n<blockquote>\u201cWe believe that corporate accelerators are a model of the past, because in a corporate accelerator you're limited to the views and the strategic input of one company. And that is never helpful for a start-up that needs to pivot. Pivoting can often only be effective if you have access to very different views on what you're doing.\u201d</blockquote>\r\nFor the same reason, the Next Media Accelerator only accepts applications from start-up teams that have the software architect as one of their founders:\r\n<blockquote>\u201cIt's a kill-criteria. If you have to completely overhaul your technical structure, the software architect needs to be at the table from the beginning. And not as an employee, but as an entrepreneur.\u201d</blockquote>\r\n<h3>New opportunities for content distribution</h3>\r\nSo far, two especially successful solutions came out of the accelerator: Contentflow and Spektrum.\r\n<blockquote>\u201cSpektrum is a big success story,\u201d Meinolf proudly announces. \u201cThe German tabloid Bild was the first one to use their messenger application for a service on soccer transfers. During the winter break very often players are sold and bought and so you could apply and register for your club, and whenever they were involved in a transfer, you\u2019d be notified.\u201d</blockquote>\r\nThere was only one bump in the road. Just when this service by Bild went live, Whatsapp had changed its rules overnight. So many people who applied for the service were rejected:\r\n<blockquote>\u201cBut due to our contacts we were able to convince Facebook to allow Spektrum to be the first and experimental partner to use the Facebook messenger API for content distribution.\u201d</blockquote>\r\n<h3>Part of the innovation ecosystem</h3>\r\nThis case illustrates the value of being part of an innovation ecosystem:\r\n<blockquote>\u201cThe core of the NMA is matching media-related startups with media and marketing corporates and enable them and moderate a process where they do prototypes and test-runs together. And I believe that this is maybe the secret sauce of the NMA,\u201d says Meinolf.\r\n\r\n\u201cSince we have this huge network of media and marketing players of different character and start-ups from all different directions, we can on the one hand provide the start-ups with dozens of different opportunities to test their product and on the other hand see where exactly it fits into the market and where it solves problems of the industry\u201d</blockquote>\r\nThis network is international. The NMA has partnerships with media accelerators in Belgium, the Netherlands, Scandinavia and the Baltic States. The old Hanseatic League network still seems to share a similar business mentality, which makes it pleasant to do business together, according to Meinolf. But the innovation ecosystem is global and so they are also working with start-ups in Israel and are planning to set up similar initiatives in New York.\r\n\r\nOn a local level, the NMA is supporting two \u2018sister\u2019-accelerators that have emerged in Hamburg since 2015: a Next Commerce Accelerator and a Next Logistics Accelerator.\r\n<blockquote>\u201cHamburg is a port-city, it's the centre in Germany of logistics and trade, and it's the centre of media and advertising. So this is the strategy for Hamburg now: Take the concept of the industry accelerators and put them on top of all the industries where Hamburg has a very strong position in the market.\u201d</blockquote>\r\nCONTACT POINT\r\n<img class=\"alignnone wp-image-11489 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2018/02/Meinolf-ellers.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\nMeinolf Ellers, Chief Digital Officer, dpa (German Press Agency)\r\nWeb: <a href=\"https://www.nma.vc/\" target=\"_blank\" rel=\"noopener\">https://www.nma.vc/</a>\r\nTwitter: <a href=\"https://twitter.com/NMA_vc\" target=\"_blank\" rel=\"noopener\">@NMA_vc</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Next Media Accelerator: the German Press Agency accelerating media and marketing start-ups in Hamburg","post_link":"https://media-innovation.news/media-lab/next-media-accelerator-german-press-agency-accelerating-media-marketing-start-ups-hamburg/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Next Media Accelerator: the German Press Agency accelerating media and marketing start-ups in Hamburg\" width=\"300\" height=\"157\" src=\"https://media-innovation.news/wp-content/uploads/2018/02/Header-300x157.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"accelerator, business models, Germany, investors, network, news agency, scalable technology, startups","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1526999842:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Hamburg, Germany","%_wpgmp_metabox_latitude%":"53.5510846","%_wpgmp_metabox_longitude%":"9.993681899999956","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_primary_category%":"69","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"11488","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545419971,"payload":[{"id":10783},{"id":11494},{"id":10991}]}},"%_publicize_pending%":"1","%_yoast_wpseo_focuskw_text_input%":"Hamburg","%_yoast_wpseo_focuskw%":"Hamburg","%_yoast_wpseo_linkdex%":"72","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"accelerator, business models, Germany, investors, network, news agency, scalable technology, startups"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11485,"infowindow_disable":false},{"source":"post","title":"EPFL+ECAL Lab: innovations should feel natural to users to be sustainable","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"EPFL+ECAL Lab: innovations should feel natural to users to be sustainable\" width=\"300\" height=\"152\" src=\"https://media-innovation.news/wp-content/uploads/2018/01/header-1-1-300x152.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">EPFL+ECAL Lab: innovations should feel natural to users to be sustainable</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Innovation is not about impressing people with the latest technologies. For the EPFL+ECAL Lab, an innovation is successful if a user forgets about the technology and instead focuses on the content.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/epflecal-lab-innovations-feel-natural-users-sustainable/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Innovation is not about impressing people with the latest technologies. For the EPFL+ECAL Lab, an innovation is successful if a user forgets about the technology and instead focuses on the content.","address":"Lausanne, Switzerland","location":{"lat":"46.5196535","lng":"6.632273400000031","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/epflecal-lab-innovations-feel-natural-users-sustainable/","zoom":2,"extra_fields":{"post_excerpt":"Innovation is not about impressing people with the latest technologies. For the EPFL+ECAL Lab, an innovation is successful if a user forgets about the technology and instead focuses on the content.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>EPFL+ECAL Lab: innovations should feel natural to users to be sustainable</h1>\r\n<strong>Innovation is not about impressing people with the latest technologies. For the EPFL+ECAL Lab, an innovation is successful if a user forgets about the technology and instead focuses on the content.</strong>\r\n\r\nCreated in 2007, the EPFL+ECAL Lab is an innovation lab in Lausanne, located in the ECAL building of the University of Art and Design Lausanne, and belonging to the Ecole Polytechnique F\u00e9d\u00e9rale de Lausanne (EPFL).\r\n\r\nIt aims to explore the potential of emerging technologies through design research:\r\n<blockquote>\u201cThe main question for media innovation is how we can transform these new technologies into convincing experiences for the user,\u201d says Nicolas Henchoz, director of the EPFL-ECAL Lab. \u201cWe tend to reduce innovation to technological performance - increased speed and increased functionality \u2013 and forget about how to make sense of them.\u201d</blockquote>\r\nDesigners, engineers and psychologists work together in the Lab. They develop functional prototypes and evaluate the cultural and emotional impact of these prototypes on the end users.\r\n<h3>Original failure</h3>\r\nNicolas and his team looked at many other initiatives for inspiration and translated their observations into a new and original approach:\r\n<blockquote>\u201cWe had the chance to observe the good and the bad aspects of all of these models and then start our own. I always said \u2018we will fail sooner or later, but at least it should be an original failure\u2019.\u201d</blockquote>\r\nInspiration for the Lab\u2019s approach comes in large part from designers Jasper Morrison and Naoto Fukasawa. They coined the term \u2018super normal\u2019 to help find the essence of normality in design:\r\n<blockquote>\u201cThis allows us to make something that is disruptive seem normal, almost like you\u2019ve seen it before. When you reach this level, you can create things that last five to ten years. And that\u2019s when you have a real return on investment for the user, for the company, for everybody.\u201d</blockquote>\r\n<h3>Content over technology</h3>\r\nAlthough it\u2019s far from easy, the EPFL-ECAL Lab has shown through several installations that it is possible to make people forget about the technology.\r\n\r\nThrough their work on immersive media, they tackled the challenge of getting from a cool 3D world that impresses people for a few minutes to a point at which people really start to look at the content. As soon as people forget about the technology, you start to see in which cases an immersive environment can be an added value.\r\n\r\nThe \u2018<a href=\"http://www.epfl-ecal-lab.ch/work/chronogram/\" target=\"_blank\" rel=\"noopener\">History of Watch Making</a>\u2019 project went through several versions:\r\n<blockquote>\u201cIn the first versions people were mostly seduced by the 3D environment,\u201d remembers Nicolas, \u201cbut on the final one people were really looking at the content. For the innovation to last, it is important that the content is perceived as something that exists and not just as something fun.\u201d</blockquote>\r\n<h3>Emotional perceptions</h3>\r\nNicolas believes that many innovative projects turn into a disaster because most of the money is invested into developing the technologies, while almost nothing goes to thinking and experimenting about the ways in which users make sense of those technologies.\r\n\r\nInnovations that feel natural incorporate the idea that experiences consist of different elements. Memories often include an image, a smell, some sounds; they are a kind of global sensation, a bit like dreams.\r\n\r\nAs an alternative, the EPFL-ECAL Lab approach doesn\u2019t just take into account the storytelling level, but also the human perception through the so-called \u2018landscape of sensation\u2019:\r\n<blockquote>\u201cThat is something very fuzzy that you acquire in the first weeks of your life. You still have it in your mind as an adult, but as we always speak with words when we try to convince the other with words and stories, we tend to forget this dimension.\u201d</blockquote>\r\n<h3>Industry partnerships</h3>\r\nClients\u2019 fund about half of the work, the school the other half. They hire the EPFL-ECAL Lab to make sense of new technologies. Nicolas explains why these firms are interested in working with the Lab, despite the although it takes them more time and is therefore more costly:\r\n<blockquote>\u201cWhen you have new topics, new domains, new challenges; nobody knows. Working with a consultancy firm that doesn\u2019t know how to deal with this and loosing your money because you end up in a dead end is probably not very efficient. And we have a very good return on investment for the company. It\u2019s very important to be clear about what we can be good at and what we can provide as an advantage.\u201d</blockquote>\r\nThe Lab accepts projects if they are convinced by it and if it brings new knowledge:\r\n<blockquote>\u201cOur lab is based on being hands-on, because design inspiration comes by doing, not only by thinking, so it must be with real people in a real case, but it must also tackle a real challenge for society.\u201d</blockquote>\r\nAs a Lab, they deliver functional prototypes, but no final products. Although the prototypes are made in such a way that it is possible for the company to develop the product further if they wish to do so: \u201cThat\u2019s also the only way to benefit society. Otherwise they have something that is really cool, but if there is no income, no funding, it will not last.\u201d\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-11414 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2018/01/nicolas-e1517233407636.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nNicolas Henchoz, Director, EPFL+ECAL Lab\r\nWeb: <a href=\"http://www.epfl-ecal-lab.ch/\" target=\"_blank\" rel=\"noopener\">http://www.epfl-ecal-lab.ch/</a>\r\nTwitter: <a href=\"https://twitter.com/epflecallab\" target=\"_blank\" rel=\"noopener\">@epflecallab</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"EPFL+ECAL Lab: innovations should feel natural to users to be sustainable","post_link":"https://media-innovation.news/media-lab/epflecal-lab-innovations-feel-natural-users-sustainable/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"EPFL+ECAL Lab: innovations should feel natural to users to be sustainable\" width=\"300\" height=\"152\" src=\"https://media-innovation.news/wp-content/uploads/2018/01/header-1-1-300x152.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic Lab, design research, Immersive, industry collaboration, prototypes, Switzerland","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1526999882:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%_publicize_pending%":"1","%_thumbnail_id%":"11422","%_wpgmp_location_address%":"Lausanne, Switzerland","%_wpgmp_metabox_latitude%":"46.5196535","%_wpgmp_metabox_longitude%":"6.632273400000031","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545365869,"payload":[{"id":11494},{"id":10144},{"id":10686}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic Lab, design research, Immersive, industry collaboration, prototypes, Switzerland"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11412,"infowindow_disable":false},{"source":"post","title":"iNOVA Media Lab: research, project development and networking with media","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"iNOVA Media Lab: research, project development and networking with media\" width=\"300\" height=\"129\" src=\"https://media-innovation.news/wp-content/uploads/2018/01/iNOVA-29-1482x635-300x129.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">iNOVA Media Lab: research, project development and networking with media</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Joining the worlds of social sciences and emerging technologies, by applying their research to media industry practices.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/inova-media-lab/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Joining the worlds of social sciences and emerging technologies, by applying their research to media industry practices.","address":"Lisbon, Portugal","location":{"lat":"38.7222524","lng":"-9.139336599999979","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/inova-media-lab/","zoom":2,"extra_fields":{"post_excerpt":"Joining the worlds of social sciences and emerging technologies, by applying their research to media industry practices.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>iNOVA Media Lab \u2013 research, project development and networking with media</h1>\r\n<strong>Joining the worlds of social sciences and emerging technologies, by applying their research to media industry practices.</strong>\r\n\r\nLocated in Lisbon, Portugal, iNOVA brings a different approach to media innovation. It aims to incorporate new digital technologies within the traditional media industries, as well as research new methods and products to improve the quality of reporting and solve issues within the media environment:\r\n<blockquote>\u201cI think media innovation is not just linked to addressing the challenges of the industry, but also to seeing what\u2019s not already there. It\u2019s about developing new modes of intermediation with content. In a way it\u2019s addressing industry problems, but it\u2019s also about conceiving and developing applied answers for the future,\u201d says Paulo Nuno Vicente, coordinator of the iNOVA Media Lab.</blockquote>\r\n<h3>Media research applied to journalism practices</h3>\r\nThe lab started in February 2016 under the vision and coordination of Paulo Nuno Vicente who looked to create a new venture for media innovation inspired by research labs from other areas.\r\n\r\niNOVA Media Lab focuses its resources on three main areas:\r\n<ul>\r\n\t<li>Conducting applied research in various digital media innovation strategies, such as immersive and interactive storytelling, digital journalism, science communication, digital methods and web platforms, information visualization and the future of education;</li>\r\n\t<li>Creating workshops and training courses for both students, researchers, professors and media professionals</li>\r\n\t<li>Offering finished products and services per request, including audio and video production using 360 degrees formats, immersive technologies and other digital devices and methods.</li>\r\n</ul>\r\n<h3></h3>\r\n<h3>PANOPTIS project</h3>\r\niNOVA Media Lab\u2019s primary interest at the moment is the development of the PANOPTIS project, an interdisciplinary project around climate change focused on redefining reporting through immersive technology.\r\n\r\nThe one-year long project is designed to take a creative and cutting-edge approach to reporting on the human contribution to climate change by developing two prototypes of immersive documentaries in two different areas: Guinea-Bissau and Madeira Island.\r\n\r\nAccording to Paulo Nuno Vicente, who is also the principal investigator for the PANOPTIS project, the objective is not only to raise awareness of the issues surrounding climate change, but also enriching the media\u2019s view on reporting by incorporating digital technologies into traditional journalism.\r\n<blockquote>\u201cIn a way, what we want to do is address contemporary issues and develop the potential coming from the language of new media. So on top of doing the traditional documentary using new media, also studying and testing how to use immersive media and data visualisation. You need to challenge the status quo.\u201d</blockquote>\r\nThe project brings together a consortium of partners across Portugal, the main ones being the Portuguese Institute for Ocean Studies and NOVA Laboratory for Computer Science and Informatics (NOVA LINCS), and also from the United States, in collaboration with University of Texas at Austin.\r\n<h3>Industry partnerships</h3>\r\nAlthough fairly new, iNOVA Media Lab's work portfolio includes a variety of projects done in collaboration with external media organisations and university students.\r\n\r\nSuch projects include the \"90 Seconds of Science\" radio programme, broadcasted daily by Antena 1, one of Portugal's national public radio stations. The programme is dedicated to presenting new and different research methods and projects done all across Portugal.\r\n\r\nThanks to the success of the radio show, iNOVA Media Lab is currently working on developing a pilot episode for a spin-off called \"5 Minutes of Science\", which will be available on TV and online.\r\n\r\niNOVA Media Lab also offers a variety of workshops and training courses surrounding immersive media, entrepreneurial journalism and storytelling using digital media technologies. These are part of their Digital Media Summer Institute, created in partnership with The University of Texas at Austin.\r\n\r\nIn January, the lab organised a Digital Media Winter Institute, dedicated to advancing the study of new media, social media methods, and data visualisation. The event promoted interdisciplinary research through the data-sprint approach and other intensive hands-on work courses.\r\n<h3>Future projects and collaborations</h3>\r\niNOVA Media Lab will enter a new phase in January 2018, which will allow it to develop different exploratory studies and prototypes connected to digital media innovation and applied research. As part of the new phase, the lab expects to grow its team by hiring new staff, bringing the total number of collaborators and employees to 13.\r\n<blockquote>\u201cI do have very clear metrics that help the development of the laboratory itself, and part of that is the ability to attract people, so PhD researchers and master students; committed, engaged and motivated people,\u201d says Paulo Nuno Vicente.</blockquote>\r\nMoreover, the team is looking to start a new, 4-year research project named \"Innov-action\", focused on analysing innovative processes and methodologies across the country. The project consists of \"mapping\" creative and new development methods within cultural industries in Portugal and producing research reports on their methods.\r\n\r\nFinally, iNOVA Media Lab is looking to increase its network by liaising with other media labs nationally and internationally, as well as maintaining and developing new relations with media industries.\r\n\r\nCONTACT POINT\r\n<img class=\"alignnone wp-image-11366 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2018/01/Paulo-Nuno-Vicente_full-1.png\" alt=\"\" width=\"200\" height=\"250\" />\r\nPaulo Nuno Vicente, coordinator, iNOVA Media Lab\r\nTwitter: <a href=\"https://twitter.com/inovamedialab\" target=\"_blank\" rel=\"noopener\">@iNOVAmedialab</a>\r\nWeb: <a href=\"http://inovamedialab.org/paulo-nuno-vicente/\" target=\"_blank\" rel=\"noopener\">inovamedialab.org</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"iNOVA Media Lab: research, project development and networking with media","post_link":"https://media-innovation.news/media-lab/inova-media-lab/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"iNOVA Media Lab: research, project development and networking with media\" width=\"300\" height=\"129\" src=\"https://media-innovation.news/wp-content/uploads/2018/01/iNOVA-29-1482x635-300x129.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic Lab, design sprint, Immersive, industry collaboration, Portugal, training and education","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1526999951:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_primary_category%":"69","%_kleo_title_checkbox%":"1","%_yoast_wpseo_focuskw_text_input%":"iNOVA","%_yoast_wpseo_focuskw%":"iNOVA","%_yoast_wpseo_linkdex%":"74","%_thumbnail_id%":"11368","%_yoast_wpseo_metadesc%":"Joining the worlds of social sciences and emerging technologies, by applying their research to media industry practices.","%_publicize_pending%":"1","%_wpgmp_location_address%":"Lisbon, Portugal","%_wpgmp_metabox_latitude%":"38.7222524","%_wpgmp_metabox_longitude%":"-9.139336599999979","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545274730,"payload":[{"id":10144},{"id":11352},{"id":10681}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic Lab, design sprint, Immersive, industry collaboration, Portugal, training and education"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11362,"infowindow_disable":false},{"source":"post","title":"Digital World Research Centre: exploring the interplay between media content, platform and experience","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Digital World Research Centre: exploring the interplay between media content, platform and experience\" width=\"300\" height=\"225\" src=\"https://media-innovation.news/wp-content/uploads/2017/12/unnamed-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Digital World Research Centre: exploring the interplay between media content, platform and experience</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            DWRC brings together engineering, communication, social science, business, design and arts to work on media innovation projects that have a concrete impact on society and culture. \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/digital-world-research-centre/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"DWRC brings together engineering, communication, social science, business, design and arts to work on media innovation projects that have a concrete impact on society and culture. ","address":"388 Stag Hill, Guildford GU2 7XH, United Kingdom","location":{"lat":"51.24257189999999","lng":"-0.5879459000000224","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/digital-world-research-centre/","zoom":2,"extra_fields":{"post_excerpt":"DWRC brings together engineering, communication, social science, business, design and arts to work on media innovation projects that have a concrete impact on society and culture. ","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Digital World Research Centre: exploring the interplay between media content, platform and experience</h1>\r\n<strong>DWRC brings together engineering, communication, social science, business, design and arts to work on media innovation projects that have a concrete impact on society and culture. </strong>\r\n\r\nThe Digital World Research Centre (DWRC) is a research network within the University of Surrey, carrying out new media innovation projects with social and cultural benefit. They conduct interdisciplinary research into new media platforms, content and experiences, and strive to commercialise and apply the findings of research in society.\r\n\r\nTheir work is focused on understanding new forms of digital media production and consumption, and developing ways of supporting them with novel media genres, formats, devices and services.\r\n\r\nCreated in 1998 as a multi-disciplinary research centre, the DWRC aims to bring together a diversity of internal and external partners for their innovation projects:\r\n<blockquote>\u201cAlthough I belong to the Department of Music and Media organisationally, I sit physically in The Department of Electrical and Electronic Engineering,\" says Director of the DWRC David Frohlich. \"Furthermore, the people I work with come from all three Faculties at Surrey, including Health and Medical sciences, Engineering and Physical Sciences, and Arts and Social Sciences.\"</blockquote>\r\n<h3>Design Research</h3>\r\nWhen David joined the Centre in 2005, he introduced innovation to the group as well as a new way of working involving design research:\r\n<blockquote>\u201cI had been working with HP Labs as a user researcher, but I got increasingly involved with design - especially design of new technology prototypes. So I started out doing studies of technology use, but these naturally led onto designing, building and testing prototypes in the wild.\u201d</blockquote>\r\nDesign research like this can be about research-for-design or research-through-design. DWRC does both, depending on the type of project.\r\n\r\nOn the <a href=\"https://www.surrey.ac.uk/digital-world-research-centre/funded-projects/community-generated-media-next-billion\"><em>Community-generated media for the next billion</em></a> project for example, research-for-design allowed them to investigate the creative use of camera phones in rural South Africa. The aim was to design a mobile digital storytelling system (the <em>Com-Me</em> toolkit) for non-textual communication.\r\n\r\nWhile on the <a href=\"https://www.surrey.ac.uk/digital-world-research-centre/funded-projects/interactive-newsprint\"><em>Interactive Newsprint</em></a> project, they did research-through-design by co-designing and creating a series of interacting print prototypes with a local community. Here the team explored the affordances of \u2018audio paper' for printed community news.\r\n<h3>Platforms, content and experiences</h3>\r\nFor David, media innovation \u201chas always been about trying to invent a new media form, a new medium if you like, for communication\u201d. DWRC is working on platforms, content and experiences at the same time, while most centres are working on only one of these. Innovation should involve those three, as working on only one at the time overlooks the interaction between these fundamental properties of media systems.\r\n\r\nThis interaction can be seen at the beginning of each new media form, according to David. In the case of cinema for example, it was not only a platform invention for recording and playing moving images with sound:\r\n<blockquote>\"Cinema also required new kinds of \u2018cinematography\u2019 in the making of filmic content as opposed to just recording plays. Content changed from silent movies to \u2018talkies\u2019 as sound was added to the platform. The experience of making and watching films depends on these interactions, and could in turn be used to drive changes in either platform or content.\"</blockquote>\r\nDavid and his team are currently applying this principle in a new project to define <a href=\"https://www.surrey.ac.uk/digital-world-research-centre/funded-projects/next-generation-paper-connecting-paper-web\"><em>Next Generation Paper</em></a>. They are conducting studies of optical and printed electronic technology for augmenting books alongside the making of new augmented book content for travel and tourism.\r\n<h3>Research with concrete results</h3>\r\nThe projects are usually research rather than development projects, which results in technological interventions that reveal new insights about how people do things with media - such as communicate, keep in touch, share, remember, understand.\r\n\r\nHowever, Digital World is also interested in the business side of media as well, because business factors shape innovation just as much or maybe even more than technology does:\r\n<blockquote>\u201cNot having a business model that works is often a barrier to the application of new media innovations in the real world. Research projects can come up with a great prototype which meets an unmet user need, but this will just die unless a company is able to develop and sell it at a profit.\u201d</blockquote>\r\nSpecifically, in the Next Generation Paper project, the business school is also involved:\r\n<blockquote>\u201cI\u2019m very pleased about that, because it means we will be able to understand the markets for this technology and use that understanding to shape the technology itself.\u201d</blockquote>\r\n<h3>Business shaping innovation</h3>\r\nHe believes the best projects are those that enable new media behaviour that people enjoy and benefit from in some way. And that companies later incorporate into their products and services:\r\n<blockquote>\u201cWe therefore tend to conceive and conduct projects nowadays with industrial and third sector partners who can make use of the insights of research in their business activities.\u201d</blockquote>\r\nThe DWRC has received industrial funding from companies such as Vodafone, Microsoft, Kodak, British Telecom, Orange, Hewlett Packard and Fujitsu, as well as from smaller creative industry and third sector organisations.\r\n\r\nCONTACT POINT\r\n<img class=\"alignnone size-full wp-image-11357\" src=\"https://media-innovation.news/wp-content/uploads/2017/12/david_frohlich.contact_0.jpg\" alt=\"\" width=\"150\" height=\"200\" />\r\nDavid Frohlich, Director, Digital World Research Centre\r\nWeb: <a href=\"https://www.surrey.ac.uk/digital-world-research-centre/people\">https://www.surrey.ac.uk/</a>\r\nTwitter: <a href=\"https://twitter.com/davidfrohlich?lang=en\">@davidfrohlich</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Digital World Research Centre: exploring the interplay between media content, platform and experience","post_link":"https://media-innovation.news/media-lab/digital-world-research-centre/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Digital World Research Centre: exploring the interplay between media content, platform and experience\" width=\"300\" height=\"225\" src=\"https://media-innovation.news/wp-content/uploads/2017/12/unnamed-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic Lab, design research, multidisciplinary, UK","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1526999994:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"11354","%_kleo_title_checkbox%":"1","%_yoast_wpseo_focuskw_text_input%":"DWRC","%_yoast_wpseo_focuskw%":"DWRC","%_yoast_wpseo_metadesc%":"DWRC brings together engineering, communication, social science, business, design and arts to work on media innovation projects that have a concrete impact on society and culture.","%_yoast_wpseo_linkdex%":"73","%_wpgmp_location_address%":"388 Stag Hill, Guildford GU2 7XH, United Kingdom","%_wpgmp_metabox_latitude%":"51.24257189999999","%_wpgmp_metabox_longitude%":"-0.5879459000000224","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1544966916,"payload":[{"id":10776},{"id":10130},{"id":11362}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic Lab, design research, multidisciplinary, UK"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11352,"infowindow_disable":false},{"source":"post","title":"Lab 351: innovation-in-a-box approach allows anyone in the company to develop their ideas and entrepreneurial skills","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lab 351: innovation-in-a-box approach allows anyone in the company to develop their ideas and entrepreneurial skills\" width=\"300\" height=\"165\" src=\"https://media-innovation.news/wp-content/uploads/2017/10/image001-e1509008596886-300x165.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lab 351: innovation-in-a-box approach allows anyone in the company to develop their ideas and entrepreneurial skills</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The Globe and Mail encourages all employees in the company to pitch as many innovative ideas as they can even if they are at the back of napkin stage.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/lab-351-innovation-box-approach-allows-anyone-company-develop-ideas-entrepreneurial-skills/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The Globe and Mail encourages all employees in the company to pitch as many innovative ideas as they can even if they are at the back of napkin stage.","address":"Toronto, ON, Canada","location":{"lat":"43.653226","lng":"-79.38318429999998","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/lab-351-innovation-box-approach-allows-anyone-company-develop-ideas-entrepreneurial-skills/","zoom":2,"extra_fields":{"post_excerpt":"The Globe and Mail encourages all employees in the company to pitch as many innovative ideas as they can even if they are at the back of napkin stage.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Lab 351: innovation-in-a-box approach allows anyone in the company to develop their ideas and entrepreneurial skills</h1>\r\n<strong>The Globe and Mail encourages all employees in the company to pitch as many innovative ideas as they can even if they are at the back of napkin stage.</strong>\r\n\r\nSelected individuals then get 2 days of accelerated innovation training and $1000 to validate some of their ideas, without knowing which idea got them got them into the lab. From there, the Lab looks to build teams on top of those findings, freeing up small groups from their daily work and funding them for up to 90 days so that they can show the company what needs to be done.\r\n\r\nThe Globe and Mail in Canada has been in print for 172 years. As the biggest newspaper in the country, it attracts a six-day readership total of over 3.5 million, making it the best-read newspaper across Canada.\r\n\r\nLab351 is part of Globe Labs, the Globe and Mail\u2019s innovation hub where data science, UX, prototyping, user testing and ideation happen. Lab351 is not staffed by a dedicated team. Instead, Gordon Edall (Director Globe Labs) tries to encourage all employees to pitch their ideas. There\u2019s an individual track and a track for small teams to tap into the resources they need to develop their ideas and turn them into projects that make a difference. Launched in June 2015, the lab was inspired by the Communitech lab at the University of Waterloo.\r\n\r\nThe Globe and Mail recently moved into a new building where the lab has a dedicated space. Although the initial idea was to extend the lab to external innovation in the form of start-up acceleration, they have decided to stick with internal innovation for the moment:\r\n<blockquote>\u201cWe haven\u2019t eliminated it as an idea that is worth considering on a regular basis and I have conversations about what that would still look like,\" says Gordon Edall, \"but external innovation would have been a much bigger investment and it would have been a much more risky endeavour.\u201d</blockquote>\r\n<h3>Excitement across the company</h3>\r\nGlobe labs however has evolved its approach to internal innovation. Before, there was a team-only approach and the size of the teams was too small to really make a difference in terms of corporate culture and the bar to get into one of the teams was very high. As one of the goals is to help change the culture in the organisation, they supplemented this team-based approach with a training programme to encourage individuals within the company to generate ideas.\r\n\r\nAn advisory committee selects the initial ideas to find the people for the intensive individual training. Using lessons and methodologies from the open-source Adobe Kickbox innovation program, selected individuals get a box with a set of innovation guidelines along with some hands-on training and a pre-paid credit card loaded with $1000 to be spent as they see fit to validate their idea:\r\n<blockquote>\u201cYou don\u2019t ever have to generate any invoices. You don\u2019t ever have to justify what you spend that money on. The money is there for you and is given to you in good faith so that you can show us what you think needs done\u201d, explains Gordon Edall. \u201cIf we give you a very small amount of money and teach you how to use it, to show us how to do something interesting and new, we believe you will do that, on your own.\u201d</blockquote>\r\nThe excitement this generates in people is infectious and spreads to others in the company, says Edall. As individuals no longer disappear for 90 days the way they did when Lab351 was first created, they can share this excitement with their colleagues while it is still fresh in their mind.\r\n<h3>Capped risk</h3>\r\nFor ideas and ventures that require more time and money but still represent an experimental idea, The Globe and Mail continues to run a competitive team-based program. Winning teams get 90 days, with team members freed from the distractions of their day jobs, to build a prototype or create a business opportunity.\r\n\r\nFunding for each team is provided up to a $100,000 threshold and the time restrictions are very real \u2013 each team understands that Lab351 is an exercise in constraint based innovation and this allows the lab to cap the risk around the innovation process.\r\n\r\nAt the end of the 90-day period, the teams know they will face another test: \u201cOnce those 90 days are up, you need your \u2018start-up\u2019 to be bought by an existing line of business here or find additional funding outside the lab,\u201d says Edall.\r\n<h3>Recognising a good idea</h3>\r\nAnybody in the company, across any department, can pitch an idea. Ideas to date have ranged from new data science capabilities to VR and other editorial projects. An important part of the process is to learn how to recognise a good idea:\r\n<blockquote>\u201cOne of the things people really struggle with in the lab is that we don\u2019t tell them which idea got them selected. When you\u2019re pitching to the lab, anyone can pitch and you can pitch as many ideas as you want. We evaluate all of the ideas anonymously and we just pick ideas and we pick ideas until we have enough people for the class. When you get into the training though we refuse to tell you what the idea was that got you selected because the training is really about being able to tell the difference between a good idea and a bad idea.\u201d</blockquote>\r\nHowever, the biggest dividend so far is not business process improvement or smarter storytelling, but a shift in the mind-set of staff: \u201cIt\u2019s about having better conversations about whether or not we should do things,\u201d says Edall. Another attractive characteristic of the Adobe Kickbox method is that it gives participants a shared vocabulary to actually talk about innovation in a more consistent way:\r\n<blockquote>\u201cIntroducing people to concepts like rapid prototyping and low fidelity testing \u2013 what we find is that when we put a few people through the training, the conversations that they have between themselves about an idea or a project are generally much better than they were before.\u201d</blockquote>\r\n<h3>Looking further ahead</h3>\r\n<blockquote>\u201cWe\u2019re still trying to figure out how far out our horizon can be. Right now we\u2019re still working on creating things tied to nearer term horizons and I hope over time we\u2019re making more bets that cross different and wider time dimensions. I want us to be we\u2019re looking at more things that are 3 to 5 years out and fewer things that are sort of quick wins.\u201d</blockquote>\r\nA good example of the types of projects Gordon Edall is aiming for are Sophi and Delphi.\r\n\r\nThe Globe and Mail has recently replaced its entire analytical infrastructure with a set of home-built tools called Sophi. It\u2019s a decision support and business intelligence tool the newsroom uses both for tactical purposes, like managing the website in real time, and strategic purposes, like re-allocating resources to address unmet needs that the advanced analytics reveal.\r\n\r\nDelphi meanwhile is a predictive analytical stack they have built on top of Sophi that, among other things, predicts the value of a story before it is published. Doing this kind of analysis prior to publication can help editors make better decisions about where to place a story or make decisions about future stories:\r\n<blockquote>\u201cWe\u2019ve shown it to a few people in the industry now and the feedback has been pretty dramatically great. People have really loved what we\u2019re able to do and the degree to which we\u2019re solving real problems in the newsroom in real time on a tactical basis and on a historical basis solving some pretty difficult issues around where to focus your effort as a newsroom.\u201d</blockquote>\r\nA mid-term project of the kind the Lab351 aspires to do more of is creating generic versions of Sophi and Delphi and opening it up to other companies, both inside the media industry or in other markets.\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-11543 size-medium\" src=\"https://media-innovation.news/wp-content/uploads/2018/03/GordonEdall12-232x300.jpeg\" alt=\"\" width=\"232\" height=\"300\" />\r\n\r\nGordon Edall, Director Globe Labs, The Globe and Mail\r\nWeb: <a href=\"https://www.theglobeandmail.com\" target=\"_blank\" rel=\"noopener\">https://www.theglobeandmail.com</a>\r\nTwitter: <a href=\"https://twitter.com/gordonedall\" target=\"_blank\" rel=\"noopener\">@gordonedall</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Lab 351: innovation-in-a-box approach allows anyone in the company to develop their ideas and entrepreneurial skills","post_link":"https://media-innovation.news/media-lab/lab-351-innovation-box-approach-allows-anyone-company-develop-ideas-entrepreneurial-skills/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lab 351: innovation-in-a-box approach allows anyone in the company to develop their ideas and entrepreneurial skills\" width=\"300\" height=\"165\" src=\"https://media-innovation.news/wp-content/uploads/2017/10/image001-e1509008596886-300x165.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"Adobe kickbox, analytics, Canada, culture of innovation, data science, internal innovation, newspaper, prototypes, staff development, training and education, UX, virtual reality","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1528728044:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"11261","%_wpgmp_location_address%":"Toronto, ON, Canada","%_wpgmp_metabox_latitude%":"43.653226","%_wpgmp_metabox_longitude%":"-79.38318429999998","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545537065,"payload":[{"id":10766},{"id":11494},{"id":10935}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"Adobe kickbox, analytics, Canada, culture of innovation, data science, internal innovation, newspaper, prototypes, staff development, training and education, UX, virtual reality"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11235,"infowindow_disable":false},{"source":"post","title":"AP Lab: including everyone in the organisation in the innovation process","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"AP Lab: including everyone in the organisation in the innovation process\" width=\"300\" height=\"163\" src=\"https://media-innovation.news/wp-content/uploads/2017/10/Associated-Press-NYC-2017-87-e1508316847559-300x163.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">AP Lab: including everyone in the organisation in the innovation process</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The Associated Press is developing a worldwide hub through internal and external innovation efforts to encourage a culture of experimentation and collaboration within the organisation.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/ap-lab-including-everyone-organisation-innovation-process/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The Associated Press is developing a worldwide hub through internal and external innovation efforts to encourage a culture of experimentation and collaboration within the organisation.","address":"New York, NY, United States","location":{"lat":"32.9216896","lng":"-80.09882390000001","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/ap-lab-including-everyone-organisation-innovation-process/","zoom":2,"extra_fields":{"post_excerpt":"The Associated Press is developing a worldwide hub through internal and external innovation efforts to encourage a culture of experimentation and collaboration within the organisation.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>AP Innovation: including everyone in the organisation in the innovation process</h1>\r\n<strong>The Associated Press is developing a worldwide hub through internal and external innovation efforts to encourage a culture of experimentation and collaboration within the organisation.</strong>\r\n\r\nThe Associated Press (AP) is a large cooperation of broadcast and newspaper organisations. With teams in over 100 countries, they cover current events from breaking news to investigative reporting in all kinds of formats, including photo, video and text.\r\n\r\nThe innovation efforts of AP were initiated three years ago, after a strategic planning process that resulted in the definition of three strategic pillars: expanding content, harnessing machine intelligence, and exploring business models beyond the core activities of AP. A culture of innovation was necessary to tie these strategic pillars together.\r\n\r\nIt was a conscious decision not to have a physical lab in which only a few people could collaborate, as a culture of innovation is rather organic:\r\n<blockquote>\u201cBeing such a large organisation; having bureaus around the world and people working from different countries, we felt for our specific case that it was better to focus on spreading this culture of innovation,\u201d says Francesco Marconi, Manager of Corporate Strategy. \u201cSo everyone could be part of that process.\u201d</blockquote>\r\n<h3>Communication is key</h3>\r\nAP is developing this culture of innovation through three major efforts. One is AP Insights on the AP website, where best practices from the industry in terms of news innovation, thought leadership and reports are gathered. It also highlights the things the Associated Press and staffers are doing around innovation, whether this is technological innovation, innovation in how to do business, or ways to collaborate with universities. \u201cAs a result a lot of people became interested in the effort,\u201d says Francesco Marconi.\r\n\r\nLast year, they created anartificial intelligence committee focused on deploying artificial intelligence across the organisation. Francesco Marconi believes innovative implementation of AI can free newsroom resources to focus on the vital journalistic tasks - like reporting, developing new sources and doing deep investigations - that humans do best. When used the right way, artificial intelligence can help maximize output in newsrooms - especially as editorial teams are challenged with less resources and smaller budgets. AI is helping them cover stories they didn\u2019t manage to cover before.\r\n\r\nThe third and perhaps most transformative effort in terms of changing the mind-set within the organisation: Inside AP. As a sort of Facebook for AP staff, Inside AP allows AP\u2019ers to follow what\u2019s happening within AP in terms of innovation. Ranging from events to updates on deals struck with another innovative company.\r\n<h3>Hub rather than a lab</h3>\r\nAll these efforts together form AP\u2019s innovation hub, built around the idea that communicating what you are doing helps create support from employees, or as Marconi says \u201cour approach to innovation is based on what we do best, which is creating content and storytelling\u201d. According to him, other things naturally emerged from that:\r\n<blockquote>\u201cwe started doing webinars and bootcamps for our staffers, where we train them in design thinking, leveraging new technologies such as virtual reality and artificial intelligence. And in the long run we also make the effort of sharing these insights with the industry.\u201d</blockquote>\r\nThis combination of learning and sharing forms the basis of a sort of AP innovation hub, which fits well the networked structure of AP with offices and journalists working all around the world. For the culture of innovation to develop, it\u2019s important to include all staffers in the process:\r\n<blockquote>\u201cWe made little posters with the strategic goals of the company, beautifully designed, and we distributed them within the company, on desks or on the wall. Again, it\u2019s just making sure that people are aware, that everyone can contribute, everyone\u2019s opinion, everyone\u2019s ideas are valuable and it\u2019s a network of knowledge that enables the company to move forward and share their expertise along the way.\u201d</blockquote>\r\n<h3>Investing in start-ups</h3>\r\nAlmost acting like a formalised outsourced innovation lab AP also has a partnership with MatterVentures. This San Francisco and New York based media incubator is funded by media organisations, including AP, the New York Times and McClatchy The start-ups go through a program that\u2019s also open for teams from the partner media companies to participate in.\r\n\r\nRight now, an AP team is working on an idea for sports innovation within that start-up program. Last year, Francesco was part of a project on Artificial Intelligence, which led to the creation of the Artificial Intelligence committee within AP.\r\n<h3>Innovation with a strategic goal</h3>\r\nInnovation is a process that\u2019s driven by a willingness to learn and share insights, but it starts with the business\u2019 needs: \u201cAll the money AP makes is reinvested back in news, in journalism, so although we\u2019re a not-for-profit company, it\u2019s important to build a healthy business.\u201d\r\nThat is what a media organisation can add. It\u2019s not just about adopting a start-up mentality; it\u2019s about combining the assets of a flexible start-up mentality with the structure of a 170-year-old company.\r\n<blockquote>\u201cSo it\u2019s not doing things or testing technology just for the sake of experimentation. We try to avoid that at all cost. We instead like to focus on very specific projects that have specific outcomes that we can measure and that doesn\u2019t have to be anything risky,\u201d explains Franscesco Marconi.</blockquote>\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-11231 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/10/Francesco-e1507651015709.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nFrancesco Marconi, Manager of Corporate Strategy, AP Lab/AP Insights\r\nTwitter: <a href=\"https://twitter.com/fpmarconi\" target=\"_blank\" rel=\"noopener\">@fpmarconi</a>\r\nWebsite: <a href=\"https://insights.ap.org/\" target=\"_blank\" rel=\"noopener\">https://insights.ap.org/</a>\r\n\r\n--\r\n\r\n<em>Header I</em><em>mage: \u201cPhoto courtesy of TPG Architecture\u201d</em>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"AP Lab: including everyone in the organisation in the innovation process","post_link":"https://media-innovation.news/media-lab/ap-lab-including-everyone-organisation-innovation-process/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"AP Lab: including everyone in the organisation in the innovation process\" width=\"300\" height=\"163\" src=\"https://media-innovation.news/wp-content/uploads/2017/10/Associated-Press-NYC-2017-87-e1508316847559-300x163.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"AI, communication, culture of innovation, external innovation, internal innovation, network, news agency, training and education, USA","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527000086:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_primary_category%":"69","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"11248","%_wpgmp_location_address%":"New York, NY, United States","%_wpgmp_metabox_latitude%":"32.9216896","%_wpgmp_metabox_longitude%":"-80.09882390000001","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545446236,"payload":[{"id":11235},{"id":11494},{"id":11714}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"AI, communication, culture of innovation, external innovation, internal innovation, network, news agency, training and education, USA"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11225,"infowindow_disable":false},{"source":"post","title":"Hackastory: teaching coders and journalists how to collaborate","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hackastory: teaching coders and journalists how to collaborate\" width=\"300\" height=\"165\" src=\"https://media-innovation.news/wp-content/uploads/2017/09/Hackastory-workshop-at-The-Next-Web-Conference-e1505833211979-300x165.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Hackastory: teaching coders and journalists how to collaborate</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Building the future of journalism by organising journalism Hackathons where multidisciplinary teams of designers, coders and journalists work together.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/hackastory-teaching-coders-journalists-collaborate/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Building the future of journalism by organising journalism Hackathons where multidisciplinary teams of designers, coders and journalists work together.","address":"Netherlands","location":{"lat":"52.13263300000001","lng":"5.2912659999999505","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/hackastory-teaching-coders-journalists-collaborate/","zoom":2,"extra_fields":{"post_excerpt":"Building the future of journalism by organising journalism Hackathons where multidisciplinary teams of designers, coders and journalists work together.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Hackastory: teaching coders and journalists how to collaborate</h1>\r\n<strong>Building the future of journalism by organising journalism Hackathons where multidisciplinary teams of designers, coders and journalists work together.</strong>\r\n\r\nHackastory founder Albertine Piels was working as a journalist for 15 years when she realised she had not once in those years worked with a newsroom developer. This struck her as strange, especially since collaboration with cameramen, producers and editors is very common within the Dutch broadcasting organisation she was working for at the time.\r\n\r\nWondering whether this surprised more professionals in the journalism field, she created a simple wordpress page where she asked people to reach out if they were interested in collaborating. Within an hour, 15 people had signed up:\r\n<blockquote>\u201cThe first Hackathon came out of this. It was an incredibly basic setup. We just welcomed all the participants and then they all started tapping on their computers. And almost all teams ran into big challenges.\u201d</blockquote>\r\n<h3>Tweaking the method</h3>\r\nAfter the first Hackathon, Albertine and her team realised they needed a better way to connect the brains of the participants during a longer period of time. They developed a process to find creative solutions for challenges in journalism. Using method cards and canvas they aim to guide journalists, coders and designers to build new products in 2,5 days. Hackastory uses principles from design thinking and agile project development and applies them to journalism:\r\n<blockquote>\u201cDuring the hackathons and workshops we observe our participants. Afterwards we interview a couple of them to learn from their experiences. And we do it again after a few months to track our impact. We truly believe you have to focus on the user. It is what we preach while developing new digital projects with our clients: audience first.\u201d</blockquote>\r\nCooperation between journalists and coders is not always easy to achieve, but the basics are simple, according to Albertine: \u201cbe curious and have fun. Two things - if you ask me - journalists are good at.\u201d\r\n<h3>Encouraging technology use</h3>\r\nBut Hackastory is not only about organising Hackathons. They also created <a href=\"https://digitalstory.tools/\" target=\"_blank\" rel=\"noopener noreferrer\">DigitalStory.Tools</a>, where they collect the tools Albertine and her team like to work with themselves. In the first 10 weeks after launch they had 25.000 views from dozens of countries and after 9 months they reached 100.000 views from 150 countries around the world. Albertine explains why this is such an important signal:\r\n<blockquote>\u201cThe internet is a powerful tool in the hands of journalists. Web technology and the possibilities of online storytelling are more important than ever before to be embraced by news media. It\u2019s crucial for journalists to stay influential in this digital era. And - we\u2019re realistic - the majority of media companies don\u2019t have a newsroom developer. Luckily, journalists can accomplish a lot with tools.\u201d</blockquote>\r\n<h3>Journalists and innovation</h3>\r\n<blockquote>\u201cJournalists respond really quickly to breaking news. If something happens on Dam Square here in Amsterdam, we\u2019ll be live reporting on that within the hour. However, we don\u2019t respond as adequately to innovation.\u201d</blockquote>\r\nAlbertine feels this is partially due to journalists\u2019 critical attitude. They need this to get to the bottom of a story, to report more profoundly on events than simply copying a press release. However, she also sees this critical attitude during their Hackathons, where it is doing more harm than good:\r\n<blockquote>\u201cJournalists are very knowledgeable and they bring this knowledge into the brainstorm sessions. They are extremely critical. This leads them to sometimes crush a seed before it has even had a chance to be planted.\u201d</blockquote>\r\n<h3>Learning to dance together</h3>\r\nKey to innovation is diversity. And while there\u2019s increasing attention for diversity in newsrooms in terms of ethnic, cultural and religious backgrounds, the need for diversity in professional backgrounds remains under-exposed:\r\n<blockquote>\u201cAround the world, journalists are still a relatively homogenous group. This leaves many possibilities untapped. The lack of collaboration between journalists and developers is like dancing alone,\u201d says Albertine.</blockquote>\r\nIn their Hackathons, Hackastory aims for groups that are 50% journalists and 50% developers. The crux seems to be in giving journalists the confidence that they have something valuable to contribute to the innovation process as well:\r\n<blockquote>\u201cA journalist participant recently told me she had believed until that moment that developers were part of some parallel universe with a very special kind of expertise. During the Hackathon she discovered that developers do not know everything either. And she, as a journalist, actually had something to contribute to the conversation other than getting coffee while the technicians were doing the work.\u201d</blockquote>\r\n<h3>Putting things into perspective</h3>\r\nIt has been a year since Albertine stopped working fulltime as a journalist, but she feels great about having more time to think about the future of journalism through Hackastory:\r\n<blockquote>\u201cI really missed this while working in the newsroom. Journalists are extremely busy and are working incredibly hard for very little money. There\u2019s no time to think about whether we\u2019re actually running this hard in the right direction.\u201d</blockquote>\r\nAt events she often hears how familiar this is for journalists, but it would benefit from being shared more often. Nonetheless, it only took The Guardian a few weeks to reach out to her after the first Hackathon with a request to organise something similar for them. Hackastory has organised 11 Hackathons so far for different legacy media worldwide and universities.\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-11200 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/09/3b68d70-e1505833756452.jpg\" alt=\"\" width=\"150\" height=\"199\" />\r\n\r\nAlbertine Piels, Founder, Hackastory\r\nWeb:\u00a0<a href=\"https://hackastory.com/\" target=\"_blank\" rel=\"noopener noreferrer\">https://hackastory.com/</a>\r\nTwitter: <a href=\"https://twitter.com/AlbertinePiels\" target=\"_blank\" rel=\"noopener noreferrer\">@AlbertinePiels</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Hackastory: teaching coders and journalists how to collaborate","post_link":"https://media-innovation.news/media-lab/hackastory-teaching-coders-journalists-collaborate/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hackastory: teaching coders and journalists how to collaborate\" width=\"300\" height=\"165\" src=\"https://media-innovation.news/wp-content/uploads/2017/09/Hackastory-workshop-at-The-Next-Web-Conference-e1505833211979-300x165.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"coding, design thinking, external lab, Hackathon, Netherlands","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527001808:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_primary_category%":"142","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"11199","%_yoast_wpseo_focuskw_text_input%":"Hackastory","%_yoast_wpseo_focuskw%":"Hackastory","%_yoast_wpseo_linkdex%":"68","%_wpgmp_location_address%":"Netherlands","%_wpgmp_metabox_latitude%":"52.13263300000001","%_wpgmp_metabox_longitude%":"5.2912659999999505","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545285577,"payload":[{"id":11765},{"id":10766},{"id":11032}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"coding, design thinking, external lab, Hackathon, Netherlands"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11195,"infowindow_disable":false},{"source":"post","title":"InVID : video verification project involving developers, academics and journalists","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"InVID : video verification project involving developers, academics and journalists\" width=\"300\" height=\"142\" src=\"https://media-innovation.news/wp-content/uploads/2017/09/post41-300x142.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">InVID : video verification project involving developers, academics and journalists</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Short for \u2018In video veritas\u2019 (in video, there is truth), InVID is creating a platform that allows journalists to verify video content from social networks more easily.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/invid-video-verification-project-involving-developers-academics-journalists/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Short for \u2018In video veritas\u2019 (in video, there is truth), InVID is creating a platform that allows journalists to verify video content from social networks more easily.","address":"Thermi, 570 01, Thessaloniki, Greece","location":{"lat":"40.5485201","lng":"23.019645999999966","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/invid-video-verification-project-involving-developers-academics-journalists/","zoom":2,"extra_fields":{"post_excerpt":"Short for \u2018In video veritas\u2019 (in video, there is truth), InVID is creating a platform that allows journalists to verify video content from social networks more easily.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>InVID : video verification project involving developers, academics and journalists</h1>\r\n<strong>Short for \u2018In video veritas\u2019 (in video, there is truth), InVID is creating a platform that allows journalists to verify video content from social networks more easily.</strong>\r\n\r\nThe EU Horizon2020 funded InVID project embarked on a mission to create a platform to detect, authenticate and check the reliability and accuracy of newsworthy video files and video content spread via social media. Although many initiatives have since been developed to fight fake news, few of them have offered solutions for video specifically:\r\n<blockquote>\u201cOne of the most interesting things that has happened in information and communication in the last 15 years is the rise of user generated content (photos, videos etc.),\u201d says Denis Teyssou, InVID\u2019s innovation manager and head of <a href=\"https://media-innovation.news/media-lab/afp-medialab/\" target=\"_blank\" rel=\"noopener noreferrer\">AFP Medialab</a>, who\u2019s one of the consortium partners. \u201cThis also comes with the difficulty of verifying this content created by the audience.\u201d</blockquote>\r\nIn an attempt to solve this challenge, the InVID platform focuses on digital files as well as contextual and user rights verifications of user-generated video on social networks. InVID started in January 2016 with journalism partners including Deutsche Welle and AFP. AFP, Deutsche Welle and the Center for Research and Technology Hellas had been partners in previous European projects and InVID started from that:\r\n<blockquote>\u201cWe discussed a new collaboration around video and we came up with the idea of verification, which was a very interesting field for research and development,\u201d adds Teyssou.</blockquote>\r\nThe project is coordinated by the Center for Research and Technology Hellas.\r\n<h3>The value of partnerships</h3>\r\nInVID is also a partner in the First Draft News network, which aims to raise awareness and address challenges relating to trust and truth in the digital age. Together with its partners, First Draft News is tackling common issues, including ways to streamline the verification process, improve the experience of eyewitnesses and increase news literacy.\r\n\r\nThrough this partnership, InVID French partner AFP has been involved in CrossCheck, a collective effort of European newsrooms to fact-check news in light of French presidential election in the spring of 2017. Being a core partner of First Draft News network was a key asset for InVID because it allowed us to learn from the \u201cverification community\u201d and to reach the community members to spread the tools we are developing.\r\n\r\nUsing a design thinking methodology, we participated and observed the CrossCheck initiative and conceived the InVID plugin during that process, as a kind of \u201cSwiss army knife\u201d offering journalists several tools to ease and speed up their verification processes.\r\n<h3>Challenges</h3>\r\nThere were some challenges the InVID team is facing, according to Teyssou. First, fake news spreads quickly from platform to platform. And while some platforms have open APIs and allow advanced search, others are closed, which makes verification more difficult. Finally, most social networks erase the original metadata of multimedia content.\r\n\r\nIn addition, managing a multidisciplinary project between different cultures can be complicated at times, although Teyssou emphasises the benefits of such collaboration. These include reaching an international market or community, expanded access to knowledge from the scientific community, and stepping out of your comfort zone encourages you to start thinking out of the box.\r\n<blockquote>\"Basically, scientists do science, engineers work on integration and APIs, and journalists work on user requirements, tests, evaluation, and dissemination,\" Teyssou explains. \"And regular teleconferences, videoconferences, working online and sharing documents, and Application Programming Interfaces (APIs) helped bridge the geographical gap between the partners and enabled collaboration across these various professional backgrounds.\"</blockquote>\r\n<h3>Open source application</h3>\r\nIn response to the growing attention for the fake news problem, InVID released a free browser plug-in in July to help journalists verify images and videos and to debunk fake video news. A couple of months later, it had been downloaded more than 500 times and received <a href=\"https://twitter.com/i/moments/888495915610275840\" target=\"_blank\" rel=\"noopener noreferrer\">good feedback</a> on social networks.\r\n\r\nThe plugin is <a href=\"http://www.invid-project.eu/tools-and-services/invid-verification-plugin/\" target=\"_blank\" rel=\"noopener noreferrer\">available</a> for Chrome and Firefox and will be maintained, refined and enhanced until the end of the project in late 2018. The plugin code has been provided in open source under a MIT license. Making the tool as widely available as possible allows them to get feedback from users, so they can continue to improve it:\r\n<blockquote>\u201cSo far we got some nice and encouraging comments from verification experts on social networks, and we hope to get valuable feedback from the community to develop more tools and improve the existing ones,\u201d says Teyssou.</blockquote>\r\nBy pasting a URL to a YouTube or Facebook video into the tool, the user can analyse its origins, including when it was uploaded, the locations featured and thumbnails retrieved from different search engines. Various options make closer inspection of the video possible, such as a magnifier and a reverse image search on several search engines.\r\n\r\nThe InVID team is currently also working on a platform which helps users discover newsworthy videos, and a web application that helps verify those videos.\r\n<div style=\"text-align: center;\"><iframe src=\"https://www.youtube.com/embed/nmgbFODPiBY\" width=\"560\" height=\"315\" frameborder=\"0\" allowfullscreen=\"allowfullscreen\"></iframe></div>\r\nCONTACT POINT\r\n<img class=\"alignnone wp-image-11165 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/09/mezar-2655446-small-e1504618573192.gif\" alt=\"\" width=\"150\" height=\"200\" />\r\nDr. Vasileios Mezaris, Information Technologies Institute (ITI), Project Coordinator InVID\r\nWeb: <a href=\"http://www.invid-project.eu/\" target=\"_blank\" rel=\"noopener noreferrer\">http://www.invid-project.eu/</a>\r\nTwitter: <a href=\"https://twitter.com/InVID_EU\" target=\"_blank\" rel=\"noopener noreferrer\">@InVID_EU</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"InVID : video verification project involving developers, academics and journalists","post_link":"https://media-innovation.news/media-lab/invid-video-verification-project-involving-developers-academics-journalists/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"InVID : video verification project involving developers, academics and journalists\" width=\"300\" height=\"142\" src=\"https://media-innovation.news/wp-content/uploads/2017/09/post41-300x142.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"Europe, fact-checking, horizon 2020, multidisciplinary, verification, video","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527001860:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"11164","%_wpgmp_location_address%":"Thermi, 570 01, Thessaloniki, Greece","%_wpgmp_metabox_latitude%":"40.5485201","%_wpgmp_metabox_longitude%":"23.019645999999966","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545520150,"payload":[{"id":10704},{"id":9945},{"id":10942}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"Europe, fact-checking, horizon 2020, multidisciplinary, verification, video"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11154,"infowindow_disable":false},{"source":"post","title":"The Brown Institute for Media Innovation: cross-pollinating innovation and \u201cMagic\u201d on America\u2019s coasts","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Brown Institute for Media Innovation: cross-pollinating innovation and \u201cMagic\u201d on America\u2019s coasts\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2017/08/Brown-Institute-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">The Brown Institute for Media Innovation: cross-pollinating innovation and \u201cMagic\u201d on America\u2019s coasts</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Exploring new forms of storytelling, with the intent of furthering both engineering research and journalistic practice.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/brown-institute-media-innovation-cross-pollinating-innovation-magic-americas-coasts/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Exploring new forms of storytelling, with the intent of furthering both engineering research and journalistic practice.","address":"Brown Institute for Media Innovation, Broadway, New York, NY, United States","location":{"lat":"40.8074859","lng":"-73.96322370000001","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/brown-institute-media-innovation-cross-pollinating-innovation-magic-americas-coasts/","zoom":2,"extra_fields":{"post_excerpt":"Exploring new forms of storytelling, with the intent of furthering both engineering research and journalistic practice.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>The Brown Institute for Media Innovation: cross-pollinating innovation and \u201cMagic\u201d on America\u2019s coasts</h1>\r\n<strong>The Brown Institute\u2019s mission is to explore new forms of storytelling, with the intent of furthering both engineering research and journalistic practice.</strong>\r\n\r\nTo this end, the institute has forged a number of significant partnerships with individuals and organisations in the research, journalism and creative communities in New York and the Bay Area.\u00a0The David and Helen Gurley Brown Institute for Media Innovation is split between Columbia University\u2019s Journalism School (East Coast, New York) and Stanford\u2019s School of Engineering (West Coast, California). It provides roughly $1m annually to spark innovation through its \u2018Magic Grant\u2019 and fellowship programmes. It has also taken on a pedagogical function within the schools, leveraging its partnerships and networks of past grantees and fellows, to bring new ideas, new questions, to the faculty, students and alumni of each school.\r\n<h3><b>Origins &amp; Mission</b></h3>\r\nThe Brown Institute\u2019s mission is simple, \u201cto look at new ways to find and tell stories,\u201d according to Brown Institute Director and Professor of Journalism at Columbia University, Mark Hansen.\r\n\r\nEstablished in 2012 with a $30m gift from Helen Gurley Brown, the former editor-in-chief at Cosmopolitan magazine for over three decades, the Institute was created to provide a platform and to inspire young people in their pursuit of advancing the media industry. The endowment was created in memory of her late husband David Brown. A graduate of both Stanford and Columbia, Brown is most well known for producing hit films like <em>Jaws</em>, <em>A Few Good Men</em> and <em>Driving Miss Daisy</em>.\r\n<blockquote>\u201cDavid and I have long supported and encouraged bright young people to follow their passions and to create original content. Great content needs useable technology. Sharing a language is where the magic happens. It's time for two great American institutions on the East and West coasts to build a bridge.\u201d</blockquote>\r\n<h3><b>Methods</b></h3>\r\nThe Brown Institute sets a late-March deadline for applications to its annual Magic Grant competition. The process itself is designed to be simple and straightforward, consisting of only a two-page proposal, a budget and CVs/resumes. After an initial screening, a shortlist of potential projects is identified, with special emphasis given to \u201cbi-coastal\u201d projects, those with teams made up of members from both the Columbia and Stanford communities. Two committees - one at each institution - are then assembled to hear oral presentations from the finalists. The committees rank the proposals and the institute directors and staff allocate funding for as many projects as they can, following the priorities set by the committees. Magic Grants can be up to $150k for a year, with that amount increasing to $300k if a project is bi-coastal.\r\n\r\nHansen sees definite advantages to journalism through such bi-coastal collaborations. Historically, journalism has tended to rely on tools and platforms that were built by technologists outside or independent of the profession, he notes. Through its training programmes and Magic Grants, the institute seeks to prepare journalists, or storytellers more broadly, to take an active role in technical development, \u201ctraining them to be tool builders and not just tool users\u201d.\r\n\r\nOver its five years, the Brown Institute staff has learned a great deal about how to create \u201cauthentic collaborations\u201d between journalists and engineers.\r\n<blockquote>\u201cWhat can happen if you\u2019re not careful is that the engineers will look at the journalists as beta testers and the journalists will look at the engineers as programmers. You don\u2019t really want projects growing up under those conditions. You want some kind of meeting in the middle.</blockquote>\r\n<h3><b>Projects</b></h3>\r\nThe intersection between technology and storytelling, and journalism, in particular, is an exceptionally fertile area. The proposals that the Brown Institute look to fund fall along a spectrum of sorts, ranging from platforms to find and tell classes of stories, to tech deep-dives producing unique ways to tell a single story, Hansen explains.\r\n\r\nTwo years ago, for example, the Brown Institute received a proposal from three Panamanian journalists, one an alumnae of the Journalism School. \u201cThe team proposed an open data portal for Panama. It turns out that Panama has the strongest freedom of information law in the Americas, from Argentina to Canada,\u201d Hansen states. \u201cSo we funded the creation of a database that would help Panamanian journalists track the operations of their government and hold the powerful to account.\u201d In May of 2017, members of the institute travelled to Panama City and met with 50 journalists and representatives of the Panamanian government. \u201cIt was amazing to see how even the most basic data had never been examined before. There was a real sense of promise in the room.\u201d\r\n\r\nAt the other end of the project spectrum, there are proposals that start with stories. With story-specific projects, the Brown Institute evaluates both the newsworthiness of the story, as well as the novelty of the technology to bring it to life. When the Institute funded a virtual reality (VR) project on the famine caused by civil war in South Sudan, the journalists in charge wanted to portray a sense of disbelief that a country with such natural beauty could also be a place of extreme hardship, Hansen explains. \u201cThe place had to appear as a kind of character in the piece and the use of VR was perfect. This was also our first partnership with PBS FRONTLINE who provided editorial supervision.\u201d\r\n\r\nThe South Sudan piece was not the only time the Brown Institute has used VR to tell a story. A recent project, presented to the Institute by a partnership between a faculty member in Columbia\u2019s School of Social Work and the Stanford Virtual Human Interaction Lab, is looking at the topic of racism. Although a common feeling around VR is that it is all about empathy, the social worker wanted to explore other aspects of what VR brings to storytelling, Hansen explains.\r\n<blockquote>\u201cThe project is about everyday experiences of racism. We found it interesting because it\u2019s bringing in another - again trying to experiment a little bit - another methodology. The social worker isn\u2019t thinking about empathy, she\u2019s more interested in how you think about a problem and the action you are motivated to take.\u201d</blockquote>\r\n<h3><b>Evaluating success</b></h3>\r\nOnce a project has gone through the application process and has been accepted by the committee, it is up to the grantees to define their important milestones and what success looks like to them. The Brown Institute assists grantees through this process with workshops on entrepreneurship, project management, and interdisciplinary collaboration. Both halves of the institute also meet quarterly in \u201cAll Hands\u201d meetings that provide an opportunity for regular group check-ins.\r\n\r\nDespite this framework, \u201csometimes the thing doesn\u2019t get where it was supposed to go; ... not all ventures are going to make it,\u201d Hansen said. \u201cEven if a project didn\u2019t turn out to be the kind amazing, award winning thing everyone hoped, if the students or the people involved have grown in the process, if the experience of it has changed the way they think about what storytelling might be or what technology is capable of - that to me is the important thing.\u201d\r\n\r\nHansen feels that the innovation and learning journey can be the most important result of the Brown Institute\u2019s funding and is what sets them apart from similar programmes.\r\n<blockquote>\u201c[Be] it a journalist learning something new about technology and now they\u2019re able to collaborate in ways they hadn\u2019t before, or technologists understanding the importance of getting journalists involved [in innovation], is something that is really valuable.</blockquote>\r\n\u201c[That is] something that I think makes our institution unique.\u201d Ultimately, Hansen points out, this goes back to the \u201cMagic\u201d in \u201cMagic Grants.\u201d \u201cHelen Gurley Brown did not really have an interest in supporting institutions \u2014 she was wanted to support people as they pursued their dreams.\u201d This, Hansen believes, makes the Brown Institute different.\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone size-full wp-image-11111\" src=\"https://media-innovation.news/wp-content/uploads/2017/08/MarkHansen-e1503417946297.png\" alt=\"\" width=\"200\" height=\"249\" />\r\n\r\nMark Hansen, Director, Brown Institute\r\nWeb: <a href=\"http://brown.columbia.edu/\" target=\"_blank\" rel=\"noopener noreferrer\">http://brown.columbia.edu/</a>\r\nTwitter: <a href=\"https://twitter.com/cocteau?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor\" target=\"_blank\" rel=\"noopener noreferrer\">@cocteau</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"The Brown Institute for Media Innovation: cross-pollinating innovation and \u201cMagic\u201d on America\u2019s coasts","post_link":"https://media-innovation.news/media-lab/brown-institute-media-innovation-cross-pollinating-innovation-magic-americas-coasts/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Brown Institute for Media Innovation: cross-pollinating innovation and \u201cMagic\u201d on America\u2019s coasts\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2017/08/Brown-Institute-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic Lab, data journalism, funding, multidisciplinary, storytelling, training and education, USA, virtual reality","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527002243:101","%_edit_last%":"101","%_thumbnail_id%":"11030","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_kleo_title_checkbox%":"1","%_wpgmp_location_address%":"Brown Institute for Media Innovation, Broadway, New York, NY, United States","%_wpgmp_metabox_latitude%":"40.8074859","%_wpgmp_metabox_longitude%":"-73.96322370000001","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545367123,"payload":[{"id":11765},{"id":10681},{"id":11362}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic Lab, data journalism, funding, multidisciplinary, storytelling, training and education, USA, virtual reality"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11032,"infowindow_disable":false},{"source":"post","title":"DMJX Media Maker Space: where the Danish School of Media and Journalism meets its community","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"DMJX Media Maker Space: where the Danish School of Media and Journalism meets its community\" width=\"300\" height=\"225\" src=\"https://media-innovation.news/wp-content/uploads/2017/08/Maker-space-1-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">DMJX Media Maker Space: where the Danish School of Media and Journalism meets its community</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Not called a \u2018Lab\u2019 but a Media Maker Space, because they\u2019re looking for co-creation rather than grand solutions.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/dmjx-media-maker-space-danish-school-media-journalism-meets-community/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Not called a \u2018Lab\u2019 but a Media Maker Space, because they\u2019re looking for co-creation rather than grand solutions.","address":"Copenhagen, Denmark","location":{"lat":"55.6760968","lng":"12.568337199999974","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/dmjx-media-maker-space-danish-school-media-journalism-meets-community/","zoom":2,"extra_fields":{"post_excerpt":"Not called a \u2018Lab\u2019 but a Media Maker Space, because they\u2019re looking for co-creation rather than grand solutions.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>DMJX Media Maker Space: where the Danish School of Media and Journalism meets its community</h3>\r\n<strong>The Media Maker Space is deliberately not called a \u2018Lab\u2019, because they\u2019re looking for co-creation rather than grand solutions.</strong>\r\n\r\nThe Danish School of Media and Journalism in Copenhagen launched the Media Maker Space in May 2017 in an attempt to further promote collaboration with its community. A new in strategy was decided on in 2016 and a main point in this strategy was to create a space to experiment that would be different from what they were doing in the classroom. Where they would be able to work across skills, functions, disciplines and work with people outside of the school.\r\n<blockquote>\u201cThe Maker Space is deliberately not called a \u2018Lab\u2019,\u201d explains DMJX Director Trine Nielsen, \u201cbecause a Lab implies something you walk into, that is very sterile and where you have some experts sitting together looking for the grand solution. Instead the Maker Space is looking for user-driven innovation, by embracing user-experience and co-creation.\u201d</blockquote>\r\nWith the Media Maker Space comes a Facebook page instead of a website, as this is more naturally oriented toward interaction and participation than the one-to-many format of a website.\r\n<h3>Collaborative work and events</h3>\r\nInnovation to Trine is about \u201cputting effort into understanding what the problem is\u201d. Not for the company, but from the users point of view. And testing your methods and tools with people outside the school: \u201cInstead of us sitting in the school, we thought, why don\u2019t we bring them in and create things together? We believe you will get better results.\u201d\r\n\r\nIn their work they seek inspiration in many places, such as <a href=\"https://innovation.sites.ku.dk\" target=\"_blank\" rel=\"noopener noreferrer\">Copenhagen University's toolbox </a>for innovation and entrepreneurship in education. They then encourage people to take a look at this toolkit and participate in a workshop where they discuss what a similar toolkit for DMJX could look like.\r\n<h3>Giving back to society</h3>\r\nAs a public institution, DMJX chooses projects that allow them to improve journalism and communication in general so the entire society will be able to benefit. The idea is to take organisations that have problems, approach them from different angles through co-creation and come up with ideas for new concepts.\r\n\r\nOne example is a project on local journalism leading up to the Danish municipal elections in October. 400 students around the country will work with different media organisations on different formats with the aim to engage young people in local politics. And to interest journalism students for local reporting:\r\n<blockquote>\u201cWhen we interview journalism students, they all say they want to go to the national broadcasting company or national or international media. Nobody wants to go into local journalism, because it\u2019s not sexy. But the most important decisions are either made at the local or at the EU level. So we said, ok, we want to make the local sexy again,\u201d says Trine.</blockquote>\r\nAnother reason is that local media organisations are struggling. They are competing with companies like Google and Facebook and don\u2019t have the same skills or financial resources to win the battle. They are not very strong on social media or digital content and do not have the same level of engagement from the users. Most of them are still stuck in the printing logic and they do not have a lot of resources to innovate.\r\n<h3>Thinking about the future</h3>\r\nThese innovation projects with media organisations allow students to get an idea of how things work outside the school. In addition to internships where they develop the skills needed to do the everyday work in newsrooms, they also have to know how to create content for the future.\r\n\r\nBut this goes both ways:\r\n<blockquote>\u201cThe academic trap is that you are evaluating what is going on instead of looking to the future,\u201d analyses Trine. \u201cSo in addition to academic methods, the DMJX teaches students to look for patterns on what companies and users are doing. You have to know what\u2019s going on outside, before you are able to think further.\u201d</blockquote>\r\nAt the same time, innovating within a university has its advantages, as it is perceived as a kind of neutral space: \u201cTV2 came to us for example with a problem and asked whether we could come up with a solution.\u201d In addition, universities are less influenced by the fast thinking mentality that\u2019s predominant in media organisations, which gives them more time and freedom to address the challenges that are relevant for society in the long-run as opposed to those relevant to a company right now.\r\n<h3>Physical space as a symbolic gesture</h3>\r\nTrine taps into her previous experience launching one of the first media labs in Denmark for the Danish broadcasting corporation in 2005. She learned that the physical aspect of an innovation effort is not the most important. This also influenced the decision for a Maker Space rather than a Lab.\r\n\r\nThe Maker Space has no staff, but people from different parts of the Journalism School are involved in running it. Many of them were also involved in actually creating the physical space.\r\n<blockquote>\u201cWe made the Media Maker Space a symbolic gesture instead. We\u2019ve created a crazy space, built all the furniture ourselves from scratch, using stuff we found on the streets and on building sites. But people are using it a lot.\u201d</blockquote>\r\nAs the school is moving to a new building in two years, they decided not to invest into the dedicated space in the old building. There will be a special space in the new building though, which will hopefully be even nicer.\r\n\r\nCONTACT POINT\r\n<h3><img class=\"alignnone wp-image-11107 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/08/skaermbillede_2016-07-01_kl._12.49.03-e1503414826119.png\" alt=\"\" width=\"199\" height=\"249\" /></h3>\r\nTrine Nielsen, Director, Danish School of Media and Journalism (DMJX)\r\nTwitter: <a href=\"https://twitter.com/dmjx\" target=\"_blank\" rel=\"noopener noreferrer\">@dmjx</a>\r\nWeb: <a href=\"https://www.facebook.com/DMJXMediaMakerSpace/\" target=\"_blank\" rel=\"noopener noreferrer\">Media Maker Space Facebook page</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"DMJX Media Maker Space: where the Danish School of Media and Journalism meets its community","post_link":"https://media-innovation.news/media-lab/dmjx-media-maker-space-danish-school-media-journalism-meets-community/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"DMJX Media Maker Space: where the Danish School of Media and Journalism meets its community\" width=\"300\" height=\"225\" src=\"https://media-innovation.news/wp-content/uploads/2017/08/Maker-space-1-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic Lab, co-creation, community-led innovation, Denmark, students, training and education","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527002305:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"11109","%_wpgmp_location_address%":"Copenhagen, Denmark","%_wpgmp_metabox_latitude%":"55.6760968","%_wpgmp_metabox_longitude%":"12.568337199999974","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545275985,"payload":[{"id":10942},{"id":11714},{"id":11691}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic Lab, co-creation, community-led innovation, Denmark, students, training and education"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11104,"infowindow_disable":false},{"source":"post","title":"J-Lab: aiding new media start-ups through training, consultancy and research","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"J-Lab: aiding new media start-ups through training, consultancy and research\" width=\"300\" height=\"135\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/j-lab-300x135.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">J-Lab: aiding new media start-ups through training, consultancy and research</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Focused on civic journalism and media entrepreneurship, J-Lab is a US-based national incubation centre that aims to promote digital media innovation within traditional media organisations and journalism start-ups.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/j-lab-aiding-new-media-start-ups-training-consultancy-research/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Focused on civic journalism and media entrepreneurship, J-Lab is a US-based national incubation centre that aims to promote digital media innovation within traditional media organisations and journalism start-ups.","address":"Washington, DC, United States","location":{"lat":"38.9071923","lng":"-77.03687070000001","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/j-lab-aiding-new-media-start-ups-training-consultancy-research/","zoom":2,"extra_fields":{"post_excerpt":"Focused on civic journalism and media entrepreneurship, J-Lab is a US-based national incubation centre that aims to promote digital media innovation within traditional media organisations and journalism start-ups.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1><strong>J-Lab: aiding new media start-ups through training, consultancy and research</strong></h1>\r\n<strong>With over 10 years of experience, J-Lab is one of the oldest digital media innovation institutions. It offers media organisations training and support to develop new ways of reporting and engaging with their audiences. </strong>\r\n\r\nOver the years, the lab has tailored its work targets and approaches to the transformations in the media environment, staying up-to-date and providing useful information to media organisations to help them adjust to these changes. Located in Washington DC, the lab acts as a national media incubator for media start-ups and traditional news organisations to incorporate digital technologies in today\u2019s media.\r\n\r\nThe lab was started in 2002 by Jan Schaffer, executive director and founder of J-Lab, as a spin-off from the Pew Centre for Civic Journalism. Its goal was to promote the use of digital technologies within the media industry:\r\n<blockquote>\u201cAt that time I made a decision that I wanted to move towards innovations in the digital media realm,\u201d Schaffer explains. \u201cBy 2002, websites were there, but they were created so you could just slap the whole newspaper online after you published it. It was very different from what we have now.\r\n\r\nWe started to get proposals that had a very interesting degree of interactivity and were very interesting for news consumers to participate in public policy issues and public policy positions, so I felt that there was a window there to develop that area a little bit more,\u201d she adds.</blockquote>\r\nJ-Lab was initially based at the University of Maryland\u2019s School of Journalism, but was later moved to the American University\u2019s School of Communications, where Schaffer teaches civic journalism and media entrepreneurship.\r\n\r\nFor many years, the lab focused on offering grants to media organisations and start-up companies in order to support the development of dozens of pilot projects. However, in 2014, J-Lab\u2019s main activities moved towards teaching, training and publishing papers, articles and studies on media innovation, giving up the task of funding new media start-ups and pilot projects:\r\n<blockquote>\u201cI made the decision that I was going to get off the hamster wheel of writing grant proposals. I didn\u2019t want to do that anymore and also, I really felt that many of the funders were doing the same thing. They didn\u2019t particularly want to fund us to do it, as they were doing it themselves. So I made the decision that I wasn\u2019t going to raise more grant money, and pivoted the centre towards teaching, training, writing and consulting.\u201d</blockquote>\r\n<h3>Results through websites and teaching</h3>\r\nAt the moment, J-Lab provides training and courses on media entrepreneurship and social journalism for graduate students at American University and CUNY\u2019s Graduate School of Journalism. Is also offers training for international journalists and journalism start-ups. An overview of the lab\u2019s work can be found on its five websites:\r\n<ul>\r\n\t<li><a href=\"http://www.j-lab.org\">j-lab.org</a>: The lab\u2019s main website, which contains articles published by Schaffer, as well as J-Lab projects, research publications and workshop and training opportunities</li>\r\n\t<li><a href=\"http://www.j-newvoices.org\">j-newvoices.org</a>: The site which focuses on incubating news start-ups, describing guidelines for grant proposals and spotlighting each year\u2019s grant winners</li>\r\n\t<li><a href=\"http://www.kcnn.org\">kcnn.org</a>: A self-help portal containing resources, research and learning modules to offer support for media start-ups and for traditional media newsrooms</li>\r\n\t<li><a href=\"http://www.j-learning.org\">j-learning.org</a>: An online how-to guide for community journalism which offers step-by-step information on building and sustaining a community news website.</li>\r\n\t<li><a href=\"http://www.newmediawomen.org\">newmediawomen.org</a>: A website dedicated to women media entrepreneurship which offers funding and resources for developing new ideas and media innovation in journalism led by women.</li>\r\n</ul>\r\nThrough funding, J-Lab has helped launch various community news start-ups around the country, such as <a href=\"http://madisoncommons.org/\">Madison Commons </a>, <a href=\"https://www.tcdailyplanet.net/\">Twin Cities Daily Planet</a>, <a href=\"http://www.chicagotalks.org\">Chicago Talks</a>,\u00a0 <a href=\"http://appindie.org/\">Appalachian Independent</a>, <a href=\"http://www.orartswatch.org/\">Oregon Arts Watch</a>, <a href=\"http://forumhome.org/\">The Deerfield Forum</a>, <a href=\"http://www.theaustinbulldog.org/\">The Austin Bulldog</a> and many others.\r\n\r\nJan Schaffer also publishes various studies, articles and books on media innovation, networked journalism and media entrepreneurship which are published on J-Lab's main website.\r\n<h3>Maintaining connections with different partners</h3>\r\nJ-Lab received funding for its activities from most of the leading journalism funders, including the Gannett Foundation. As one of the leading funders in the US media industry, the Gannett Foundation collaborated on funding a training summit for women news entrepreneurs and develop case studies and start-up resources. The Lab also has close ties with Knight Foundation, the national foundation dedicated towards funding art and media innovation projects and organisations, that was a main collaborator for the KCNN.org website and the Knight-Batten Awards for Innovations in Journalism.\r\n\r\nIn addition to this, J-Lab worked closely with the Robert R. McCormick Foundation on the New Media Women Entrepreneurs project, offering learning resources and funding for media start-ups led by women.\r\n\r\nOver the years, J-Lab has also partnered with the National Association of Black Journalists, LION publishers, the Online News Associations and many other organisations to create and develop various media innovation projects.\r\n<h3>Future development of the lab</h3>\r\nJ-Lab will continue to provide learning opportunities, training courses and consultancy for media entrepreneurs and for the use of digital technologies within media organisations to offer audiences better content in a more interactive way. In addition to this, the lab will continue to publish research papers and articles on media innovation and its impact on the present journalism environment.\r\n\r\nAlthough she is open to helping start-ups focused on virtual and augmented reality, Schaffer is primarily interested in building the capacity for news innovations that contribute to building civic capital rather than developing projects focused on the latest digital technologies:\r\n<blockquote>\u201cFor me, I think it\u2019s more than developing a new app or a new toy or a new piece of software. My work has always been grounded in the civic news and information landscape. And so I think the whole purpose of journalism and the whole purpose of innovating in journalism is to figure out what jobs citizens need media to do, and how do we do them effectively so that we\u2019re giving citizens the information they need to do their jobs as citizens,\u201d she adds.</blockquote>\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-11025 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/jan-schaffer-e1502959061317.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nJan Schaffer, Executive Director and Founder, J-Lab\r\nWeb: <a href=\"http://www.j-lab.org/\" target=\"_blank\" rel=\"noopener noreferrer\">http://www.j-lab.org/</a>\r\nTwitter: <a href=\"http://twitter.com/janjlab\" target=\"_blank\" rel=\"noopener noreferrer\">@janjlab</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"J-Lab: aiding new media start-ups through training, consultancy and research","post_link":"https://media-innovation.news/media-lab/j-lab-aiding-new-media-start-ups-training-consultancy-research/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"J-Lab: aiding new media start-ups through training, consultancy and research\" width=\"300\" height=\"135\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/j-lab-300x135.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"entrepreneurship, funding, incubator, startups, training and education, USA","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527002344:101","%_edit_last%":"101","%_thumbnail_id%":"11026","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_focuskw_text_input%":"J-Lab","%_yoast_wpseo_focuskw%":"J-Lab","%_yoast_wpseo_linkdex%":"68","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_wpgmp_location_address%":"Washington, DC, United States","%_wpgmp_metabox_latitude%":"38.9071923","%_wpgmp_metabox_longitude%":"-77.03687070000001","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545525946,"payload":[{"id":11362},{"id":10681},{"id":10942}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"entrepreneurship, funding, incubator, startups, training and education, USA"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":11024,"infowindow_disable":false},{"source":"post","title":"Texas State University MILab: Introducing media innovation into university teaching","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Texas State University MILab: Introducing media innovation into university teaching\" width=\"300\" height=\"203\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/lab_door-300x203.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Texas State University MILab: Introducing media innovation into university teaching</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Through their work with Web development, virtual reality/360 video, drone journalism and multimedia storytelling, the team is looking to influence digital media disciplines.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/texas-state-university-media-innovation-lab-introducing-media-innovation-university-teaching/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Through their work with Web development, virtual reality/360 video, drone journalism and multimedia storytelling, the team is looking to influence digital media disciplines.","address":"San Marcos, TX, United States","location":{"lat":"29.8832749","lng":"-97.94139410000002","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/texas-state-university-media-innovation-lab-introducing-media-innovation-university-teaching/","zoom":2,"extra_fields":{"post_excerpt":"Through their work with Web development, virtual reality/360 video, drone journalism and multimedia storytelling, the team is looking to influence digital media disciplines.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1><strong>Texas State University MILab: introducing media innovation into university teaching</strong></h1>\r\n<strong>Through their work with Web development, virtual reality/360 video, drone journalism and multimedia storytelling, the team is looking to influence digital media disciplines and research the constant evolution of the media industry.</strong>\r\n\r\nLocated in San Marcos, <a href=\"http://www.masscomm.txstate.edu/media-innovation.html\" target=\"_blank\" rel=\"noopener noreferrer\">Texas State University\u2019s Media Innovation Lab</a> (MILab) in the School of Journalism and Mass Communication) focuses on introducing media innovation into the academic curriculum. The digital research lab was officially started in 2016 with the opening of a lab classroom, student\u00a0 lab and maker space.\r\n\r\nHowever, the lab\u2019s activity goes back more than a decade, during which time the team, led by Cindy Royal, director of the Texas State University Media Innovation Lab, has developed innovative courses, conducted research on digital innovation and created innovation projects.\r\n\r\nThe lab features a maker space that offers assistance to students, faculty members and others with a project idea, as well as a classroom where students attend various digital media innovation courses. It also serves as a regular meeting spot for the Digital Media team and other university organisations to arrange collaborations between faculty members and students on various projects.\r\n<h3>Meaningful for the profession</h3>\r\nTexas State University\u2019s MILab focuses primarily on academic research and influencing undergraduate and postgraduate digital media teaching. Director of the Media Innovation Lab Cindy Royal believes academic research and evolution of university media courses to be the foundation to a better understanding of the current media environment:\r\n<blockquote>\u201cA lot of the things that we\u2019re making are in the structure of courses. We\u2019re instructing students right now in hopes that they\u2019re creating things that will improve their portfolio, things that we can submit to competitions, and then maybe eventually out of that something viable from a business perspective will come out of it,\u201d she explains.</blockquote>\r\n<img class=\"aligncenter wp-image-10961 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/milab_class.jpg\" alt=\"\" width=\"1500\" height=\"1034\" />\r\n\r\nThe team combines traditional approaches to academic research, using surveys, experiments and content analyses, with ethnography and qualitative, thematic analysis to explore new methods associated with media innovation. The MILab\u2019s work has been published in <a href=\"http://www.niemanlab.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Nieman Journalism Lab</a> the <a href=\"http://isoj.org/research/\" target=\"_blank\" rel=\"noopener noreferrer\">International Symposium on Online Journalism</a> and <a href=\"http://mediashift.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Mediashift</a>:\r\n<blockquote>\u201cWe\u2019re trying to be innovative in the way we think about research, as well and try to do research that\u2019s meaningful to the profession, as opposed to doing just what we think will get published,\u201d Royal says.</blockquote>\r\n<h3>ElectionLand project with ProPublica</h3>\r\nOne of the biggest projects completed by MILab was launching the Digital Media Innovation undergraduate degree, which was approved in August 2016 and which currently has 113 students enrolled.\r\n\r\nOther projects include a collaboration with<a href=\"https://www.propublica.org/\" target=\"_blank\" rel=\"noopener noreferrer\"> ProPublica</a> for the <a href=\"https://projects.propublica.org/electionland/\" target=\"_blank\" rel=\"noopener noreferrer\">ElectionLand</a> event, where the Media Innovation Lab and university students were in charge of monitoring election improprieties through social media and detecting any issues arising, as well as the AEJMC (Association for Education in Journalism and Mass Communication) pre-conference on bringing digital into the university curriculum, which will be held in Chicago in August 2017.\r\n\r\n<img class=\"aligncenter wp-image-10962 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/dale_ut.jpg\" alt=\"\" width=\"960\" height=\"720\" />\r\n\r\nAs the lab\u2019s primary focus is developing and evolving the academic curriculum, the Media Innovation Lab\u2019s projects also include a variety of courses focused on digital technologies. By experimenting with different formats, the MILab can quickly introduce cutting-edge topics. Students can take short courses in virtual reality, 360 digital filming, coding and mobile application development, but can also opt for a longer-format, immersive, summer coding bootcamp.\r\n\r\n&nbsp;\r\n<h3>Eager to collaborate</h3>\r\nThe Media Innovation Lab collaborates with local media and state organisations to offer students a variety of opportunities to learn more about digital innovation. Some of the partners include the Hacks/Hackers organisation, Texas Parks and Wildlife and the Meadows Centre for Water and the Environment at Texas State. They also work with <a href=\"https://www.sxsw.com/\" target=\"_blank\" rel=\"noopener noreferrer\">South by Southwest</a>, where students get to attend and cover the event and learn about the production of the large-scale festival.\r\n\r\nThe Media Innovation Lab is keen to continue their current endeavours of staying up-to-date with digital innovation. Cindy Royal adds the lab is looking forward to continuing to tailor and improve their academic courses over the next years, as well as continuing to publish academic research and develop innovation projects.\r\n\r\nThe team is also eager to enlarge their network and collaborate with new partners and staff members on any potential projects that are in line with the lab\u2019s goals. The MILab recently received a grant from the university for virtual reality, 360 video, live streaming and drone equipment to improve their ability to tell stories about parks and the outdoors.\r\n\r\nIn addition to this, MILab is currently participating on the committee developing the Digital Media certification from the ACEJMC (Accrediting Council on Education in Journalism and Mass Communication. Moreover, the lab is working on a PhD training bootcamp to improve teaching in digital media studies.\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-10943 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/Cindy_Royal_H9993_Web_rect-e1500038053177.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nCindy Royal, Director, Texas State University Media Innovation Lab\r\nWeb: <a href=\"http://www.masscomm.txstate.edu/media-innovation.html\" target=\"_blank\" rel=\"noopener noreferrer\">http://www.masscomm.txstate.edu/media-innovation.html</a>\r\nTwitter: <a href=\"https://twitter.com/CindyRoyal\" target=\"_blank\" rel=\"noopener noreferrer\">@CindyRoyal</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Texas State University MILab: Introducing media innovation into university teaching","post_link":"https://media-innovation.news/media-lab/texas-state-university-media-innovation-lab-introducing-media-innovation-university-teaching/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Texas State University MILab: Introducing media innovation into university teaching\" width=\"300\" height=\"203\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/lab_door-300x203.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"360 digital filming, academic research, coding, digital media, training and education, USA, virtual reality","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527002654:101","%_edit_last%":"101","%_thumbnail_id%":"10963","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_focuskw_text_input%":"media innovation lab","%_yoast_wpseo_focuskw%":"media innovation lab","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_wpgmp_location_address%":"San Marcos, TX, United States","%_wpgmp_metabox_latitude%":"29.8832749","%_wpgmp_metabox_longitude%":"-97.94139410000002","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545507499,"payload":[{"id":11362},{"id":10754},{"id":10681}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"360 digital filming, academic research, coding, digital media, training and education, USA, virtual reality"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10942,"infowindow_disable":false},{"source":"post","title":"Independent Lab: developing products through developing people","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Independent Lab: developing products through developing people\" width=\"300\" height=\"145\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/INTRANET-4529-300x145.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Independent Lab: developing products through developing people</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The lab within Independent Media is training technology graduates in media, so they get can apply technology in the newsroom and innovate in the media sector. \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/10935/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The lab within Independent Media is training technology graduates in media, so they get can apply technology in the newsroom and innovate in the media sector. ","address":"Cape Town, Western Cape, South Africa","location":{"lat":"-33.9248685","lng":"18.424055299999964","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/10935/","zoom":2,"extra_fields":{"post_excerpt":"The lab within Independent Media is training technology graduates in media, so they get can apply technology in the newsroom and innovate in the media sector. ","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Independent Lab: developing products through developing people</h1>\r\n<strong>The lab within Independent Media is training technology graduates in media, so they can apply technology in the newsroom and innovate in the media sector.</strong>\r\n\r\nIndependent Media is a South African company based in Cape Town. With 24 major newspaper titles that cater to 10 million readers daily and a unique online audience of almost three million, it is one of the leading multi-platform content companies in the country.\r\n\r\nIndependent Lab was born in December 2016. As a largely print-focused organisation, Independent Media asked Kaya Labs to create an environment aimed at introducing graduates in the technology sector to the media industry:\r\n<blockquote>\u201cEssentially become the environment in which Independent Media can develop new products through developing people,\u201d says Wesley Diphoko, founder of Kaya Labs and now Head of the Independent Lab and Online Editor.</blockquote>\r\nWhile there is a need among media companies to integrate technology in order to remain competitive, there are few tech people in the local market who are trained to work in media. The project will therefore focus on enabling the candidates to get a very good understanding of the media with the purpose of assisting them to use their understanding of technology in the media industry:\r\n<blockquote>\u201cThe success of this project will be instrumental in the transformation currently underway within Independent Media. It will allow Independent to get the necessary human resources who can assist the company to withstand the technology challenges faced by the media sector,\u201d explains Wesley Diphoko.</blockquote>\r\n<h3>The Lab</h3>\r\nThe project will assist the candidates to apply their technology skills in the media industry, which will go a long way in skills development of technology graduates. 15 graduated computer scientists form the first group that is working in the Lab, from December 2016 until November 2017. The idea is to have a larger group next year.\r\n\r\nThere is close collaboration with major universities in South Africa that are training computer scientists either for a job in academics or for more general technology jobs but not to work in media. Wesley approached them and told them about a 12-month internship program at Independent Lab. For many of the tech graduates this is their first job, the first time working on practical projects.\r\n\r\nAlthough no targets were set for Independent Lab with the signing of the first year contract in December 2016, they have already developed a number of solutions that will be useful for the newsroom. For example Infonomist, which is a data journalism project that will collect facts in a database that\u2019s directly accessible for the journalists. It will allow them to create stories based on data and is a response to the fake news problem. Or a graphics platform that will enable journalists to have access to infographics.\r\n<h3>A double role</h3>\r\nThese developments are inspired by the fact that Wesley works at the intersection of media and technology. At the same time he is responsible for training technology graduates in media at the Independent Lab and operates as an Online Editor for Business Report, one of Independent Media's publications. This approach is not understood easily by traditional people in media, he feels, but he believes there\u2019s a big advantage to working within the innovation lab while also being part of the newsroom:\r\n<blockquote>\u201cYou innovate because you feel a pain. And because I\u2019m working as a reporter as well, I feel certain pains that we can then develop a solution for in the media lab. At the same time, a normal editor doesn\u2019t have time to think about innovations because he has the 24/7 task of making sure the site runs.\u201d</blockquote>\r\nHe suggests there might even be need for a new type of editor within newsrooms that has a lesser workload, but is still involved in the newsroom. This person would be aware of what\u2019s happening in the newsroom, while also having the time to think about possible solutions for some of the challenges he encounters.\r\n<h3>Understanding each other</h3>\r\nA related element that Wesley is trying to achieve in his work within Independent Media is to get people to understand each other. People from different departments of the company regularly come to give a lecture to the tech graduates. They talk to them about subjects as varied as marketing, editorial and business.\r\n\r\nBut this is not just important for the tech graduates in the lab. Wesley believes it\u2019s important to understand what other people in the company do to allow for collaboration and cross-pollination:\r\n<blockquote>\u201cThere is always this separation between business and journalism. So you have the business and the editorial. And then you have creative elements that also traditionally sit outside of editorial in most media organisations. But if they would work together, they could make better stories.\u201d</blockquote>\r\n<h3>Internal innovation and trust</h3>\r\nWesley\u2019s initial idea was to set up an independent media innovation lab that would work on solutions for various media companies in South Africa. But he quickly learned that the media industry is very competitive. As an information architect, he's not rooted in the journalism profession, but soon after he started working on the media lab, Independent asked him to become a business editor for one of their publications as well. And he left his position as CEO of his company Kaya Labs to focus entirely on his work within Independent Media.\r\n\r\nAlthough open innovation is generally referred to as the ideal, Wesley finds that him being part of the company instead of being an external contractor makes the company more open to him and this makes innovation easier. In addition, the speed at which you need to develop makes it hard to rely on external entities to develop internal capacity.\r\n\r\nThe ultimate goal is to create a dedicated division within Independent Media that will be entirely focused on developing solutions for the newsroom.\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone size-medium wp-image-10936\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/WesleyDiphoko_Colour-200x300.jpg\" alt=\"\" width=\"200\" height=\"300\" />\r\n\r\nWesley Diphoko, Head Independent Lab and Online Editor.\r\nTwitter: <a href=\"https://twitter.com/wesleydiphoko\" target=\"_blank\" rel=\"noopener noreferrer\">@wesleydiphoko</a>\r\nWebsite: <a href=\"http://www.kaya-labs.org\" target=\"_blank\" rel=\"noopener noreferrer\">www.kaya-labs.org</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Independent Lab: developing products through developing people","post_link":"https://media-innovation.news/media-lab/10935/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Independent Lab: developing products through developing people\" width=\"300\" height=\"145\" src=\"https://media-innovation.news/wp-content/uploads/2017/07/INTRANET-4529-300x145.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"computer scientists, internal innovation, South Africa, training and education","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1586790604:1","%_edit_last%":"101","%_thumbnail_id%":"10937","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_wpgmp_location_address%":"Cape Town, Western Cape, South Africa","%_wpgmp_metabox_latitude%":"-33.9248685","%_wpgmp_metabox_longitude%":"18.424055299999964","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545535421,"payload":[{"id":11024},{"id":11714},{"id":11362}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"computer scientists, internal innovation, South Africa, training and education"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10935,"infowindow_disable":false},{"source":"post","title":"Roularta Mediatech Accelerator: media for equity for advertising and media technology startups","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Roularta Mediatech Accelerator: media for equity for advertising and media technology startups\" width=\"300\" height=\"192\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/WOB16839_RMG_Accelerator_v2-300x192.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Roularta Mediatech Accelerator: media for equity for advertising and media technology startups</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Roularta Mediatech Accelerator is a programme initiated by the Roularta Media Group, together with Duval Union, to provide support and guidance for media technology startups.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/roularta-mediatech-accelerator-media-equity-advertising-media-technology-startups/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Roularta Mediatech Accelerator is a programme initiated by the Roularta Media Group, together with Duval Union, to provide support and guidance for media technology startups.","address":"Roularta Media Group, Meiboomlaan, Roeselare, Belgium","location":{"lat":"50.9337159","lng":"3.1174813000000086","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/roularta-mediatech-accelerator-media-equity-advertising-media-technology-startups/","zoom":2,"extra_fields":{"post_excerpt":"Roularta Mediatech Accelerator is a programme initiated by the Roularta Media Group, together with Duval Union, to provide support and guidance for media technology startups.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Roularta Mediatech Accelerator: media for equity for advertising and media technology startups</h1>\r\n<strong>The Belgian Roularta Media Group offers selected startups funding, hands-on business advice for the further development and marketing strategy of the start-up and media exposure in return for a share of 5% in their companies. Depending on the start-up, this may be either a convertible note or straight equity.</strong>\r\n\r\nRoularta Media Group is a Belgian multimedia group that is the market leader in the field of radio and television, various types of magazines in Dutch and French, and local media in Flanders. RMG employs more than 2,000 people and generates combined revenues of 500 million euros.\r\n\r\nIn September 2016, they launched the Roularta Mediatech Accelerator out of the belief that organisations have to collaborate with each other to make innovation happen:\r\n<blockquote>\u201cWe were standing on the sideline and we saw startups were coming into the market and they have problems to work together with the traditional media organisations,\u201d explains Erwin Danis, Director premedia. \u201cAnd so we wanted to see how traditional media companies, also our own company, could join forces with innovative startups to reshape the future of the media.\u201d</blockquote>\r\nThe Mediatech Accelerator facilitates start-ups in the advertising and media technology field with Roularta\u2019s housing, infrastructure and technology, in return for a 5% stake in their companies. The link with Roularta is also believed to boost the startups' image and credibility through content management and storytelling.\r\n<h3>Selecting the start-ups</h3>\r\nThe accelerator programme is aimed at start-ups that will contribute something to the future of media or advertising, or perhaps even completely rewrite it. Moreover, the start-up needs to be an already established business with a VAT number, some regular customers and a thought-through business plan. Its product should be robust and scalable in the sense that it could handle sudden and unexpected changes. It's not enough to have a good idea.\r\n\r\nRoularta Media Group and Duval Union organise pitches to select the best start-ups. This gives start-ups a chance to present and promote their plans. The most important thing they are looking at is the quality of the business and the ambition of the presenters. Out of the fifty applications they received, twenty had been invited to pitch their company. Erwin Danis emphasises they were not looking for media-related companies specifically, \u201cbut fortunately out of the nine startups we selected, six happened to be working on topics that are of direct interest to our media group.\u201d\r\n\r\nThis allows them to develop some projects together as well. Look Live Media is working with sport clubs, asking people to make videos, they send them in and can win something and do a sort of final at the end of the season. With TillAlways that is developing new types of memorial ads online, they are looking at ways to also present these nicely in print in the newspaper. With neighbourhood social media app Hoplr they are exploring how they can get some of their regional content to the people and also get back content from them.\r\n\r\nBut non media-related companies are also interesting, according to Erwin Danis:\r\n<blockquote>\u201cA media company is a big boat and we should not only do things within our boat, but also do new business besides the boat, for example rescue vessels or launching a zodiac into the water. The zodiac can also be related to media, but it does not have to be. And so that's why we're looking for different kinds of startups.\u201d</blockquote>\r\n<h3>Innovation process</h3>\r\nAfter the startups have been selected, they are going into a program consisting among other things of weekly half-day mentor sessions and the possibility to organise brainstorm sessions with the mentors in case the startups have a specific question. The mentors are specialised in a variety of subjects relevant to the startups development, ranging from social media and lean marketing to legal issues.\r\n\r\nRoularta Media Group joined forces with Duval Union, an ecosystem of innovative businesses which helps organisations to keep up to date with the new digital world we live in. They have more experience working with startups. Specifically, startups will be mentored by one of the accelerator's 6 Roularta professionals and 6 expert mentors. These are available to all the startups in the accelerator.\r\n\r\nFollowing the 18-week long Accelerator programme, there will be a graduation day. On this day, as well as pitching, the 10 start-ups will have the opportunity to talk to Roularta Media Group, VCs and business angels about their possible next steps of mentoring.\r\n<h3>Media for equity</h3>\r\nAlthough more specialised accelerators might exist, the biggest benefit the Roularta Media Group has to offer startups is 25,000 euros of funding and media coverage. These advertising campaigns are meant to give the startups access to the public and the market, as they are generally at the beginning of their development and not well-known yet\r\n\r\nRoularta is also offering advice on how best to approach the market and start-ups can make use of the media space on offer to increase their brand awareness. Together with a communications person at Roularta, the startups will elaborate a media plan for which they have access to all the channels that RMG disposes of, including television, radio, print and web.\r\n\r\nHow this will work exactly, remains to be seen as the first selection of startups is graduating in June and many of them have not yet reached the point where they are ready to start marketing their product. So far, the Mediatech Accelerator is above all helping the startups to focus their endeavours, says Erwin Danis: \u201cThe startups are working really generally. They have an idea, but the end target is not clear. Our main job is to find their end target and then they can work much better.\u201d\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-10796 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/Erwin_Danis.png\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nErwin Danis, Director premedia, Roularta Media Group\r\nWeb: <a href=\"http://www.roulartamediatech.be/en\">http://www.roulartamediatech.be/en</a>\r\nTwitter: <a href=\"https://twitter.com/RMGmediatech\">@RMGmediatech</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Roularta Mediatech Accelerator: media for equity for advertising and media technology startups","post_link":"https://media-innovation.news/media-lab/roularta-mediatech-accelerator-media-equity-advertising-media-technology-startups/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Roularta Mediatech Accelerator: media for equity for advertising and media technology startups\" width=\"300\" height=\"192\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/WOB16839_RMG_Accelerator_v2-300x192.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"accelerator, Belgium, business coaching, community journalism, funding, media for equity, media house, sports, startups","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527002962:101","%_edit_last%":"101","%_thumbnail_id%":"10789","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%_kleo_title_checkbox%":"1","%_yoast_wpseo_focuskw_text_input%":"Roularta","%_yoast_wpseo_focuskw%":"Roularta","%_yoast_wpseo_linkdex%":"72","%_wpgmp_location_address%":"Roularta Media Group, Meiboomlaan, Roeselare, Belgium","%_wpgmp_metabox_latitude%":"50.9337159","%_wpgmp_metabox_longitude%":"3.1174813000000086","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545329173,"payload":[{"id":11485},{"id":10101},{"id":11494}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"accelerator, Belgium, business coaching, community journalism, funding, media for equity, media house, sports, startups"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10783,"infowindow_disable":false},{"source":"post","title":"Media Innovation Studio: international research, creative methods and multidisciplinary approaches","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Media Innovation Studio: international research, creative methods and multidisciplinary approaches\" width=\"300\" height=\"144\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/mis3.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Media Innovation Studio: international research, creative methods and multidisciplinary approaches</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            UCLan's Media Innovation Studio is a research centre and learning media lab which engages in a broad variety of media activities, including drone journalism, progressive media teaching, media research and product development.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/media-innovation-studio-international-research-creative-methods-multidisciplinary-approaches/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"UCLan's Media Innovation Studio is a research centre and learning media lab which engages in a broad variety of media activities, including drone journalism, progressive media teaching, media research and product development.","address":"University of Central Lancashire, Preston, United Kingdom","location":{"lat":"53.7645034","lng":"-2.7083505000000514","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/media-innovation-studio-international-research-creative-methods-multidisciplinary-approaches/","zoom":2,"extra_fields":{"post_excerpt":"UCLan's Media Innovation Studio is a research centre and learning media lab which engages in a broad variety of media activities, including drone journalism, progressive media teaching, media research and product development.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]\r\n<h1>Media Innovation Studio: international research, creative methods and\u00a0multidisciplinary approaches</h1>\r\n<strong>Spanning disruptive technologies, data journalism, 3D manufacturing, community engagement and storytelling, the Media Innovation Studio has a broad remit to explore innovation from many perspectives.</strong>\r\n\r\nBased at the University of Central Lancashire in the UK, the Media Innovation Studio was formed in 2012 by a core team of journalism and media academics with a remit to explore, research and create prototype technologies and their impact on communities and society.\r\n\r\nBased around an action research model \u2013 one that creates products, prototypes and processes in addition to studying their effectiveness, the Studio also feeds into the student experience. Acting as a \u2018learning lab\u2019, it seeks to create innovative teaching experiences for journalism and media students from across the university\u2019s Faculty of Culture and the Creative Industries.\r\n\r\nThe Studio has four key values: to innovate media, conduct world class research, foster interdisciplinary working through creative collaboration and to enrich community, in whatever form they may take.\r\n\r\nJohn Mills, a research and lecturer based at the Studio and one of the founding members, explains:\r\n<blockquote>\u201cThe Studio was founded to create an interdisciplinary lab that would research and create new technologies and systems. As a research lab, we\u2019re also interested in how technology can disrupt as well as reinforce, so much of our work is challenging to industry and sector norms, or presenting existing technologies in new and innovative ways.\u201d</blockquote>\r\n<h3><strong>Methods</strong></h3>\r\nWith a range of disciplines based out of the Studio, it deploys a range of methods to gain and gather insights, generate data, prototype and test. These span creative facilitation, Hacks, deploying cultural probes, which seek to generate rich insights rather than mass data, and rapid prototyping. The team also seeks to collaborate with partners, and industry and community connections to ensure the projects they run have rich research base and relevance to audiences, communities and users.\r\n<blockquote>\u201cThrough combining a range of methodological approaches, we hope to create unique and novel insights to prototype development and research pathways,\u201d Mills explains.</blockquote>\r\nThe team also leans on standard social sciences methods, such as carrying out semi structured interviews, surveys and traditional market and academic reviews and market reports. What forms the centre the work, is to prototype, test and iterative, which leans on more agile development approaches.\r\n<h3><strong>Projects </strong></h3>\r\nThe Media Innovation Studio has been involved in a wide variety of projects since it formed. These include the Civic Drone Centre, which sought to understand how UAVs could \u201cbe used for good\u201d across search and rescue, humanitarian aid and media uses, and DataMakers\u00a0.\r\n\r\nMore recently, the team have been exploring the Internet of Things, proximity broadcasting and hyperlocal data. Examples include:\r\n<ul>\r\n \t<li><strong>NewsThings:</strong> Funded by Google\u2019s Digital News Initiative, NewsThings is exploring what news and information-themed Internet of Things could be through working closely with audience, newsrooms and a multidisciplinary team. Project partners include Trinity Mirror Regionals and creative agency Thomas Buchanan. For more info on the NewsThings project, head over to our dedicated project profile page.</li>\r\n \t<li><strong>CAST</strong>: CAST is a research project that is currently running in Armenia. We are introducing a local WiFi/intranet-style network to three remote villages. The project is looking into whether information can be provided in remote locations with little to no connectivity, or where connectivity is expensive or unreliable, as well as places where media may be controlled. It will test new digital ways for villages to connect with news, information and each other, without being connected to the internet. We will be using WiCastr devices. It uses freely available WiFi to make content available that you can access on your phone or laptop. Our hope is to support local communities in Armenia to develop and thrive. The aim is to test CAST as a digital \u2018word of mouth\u2019 tool and to see how this new technology can be used to make news and information available, especially in areas which have limited access to such resources. The research aims to prompt and demonstrate the social and commercial potential of CAST as a new local media ecosystem.</li>\r\n \t<li><strong>Media Mill: </strong>While the field of open data is not new, it is becoming apparent how little it is utilised at a hyperlocal level: only 4% of 18,000 data sets in direct.gov.uk come from the 326 local councils. The Media Mill\u00a0project aims to drive the development of open source, open data platforms in Leeds and York; enable collaboration between all partners to identify ways that local data can be transformed into media experiences (with an emphasis on mobile) that have value for citizens; and support research into the various business propositions that surround the project with a view to sustaining a thriving hyperlocal media ecology for the city-region.</li>\r\n \t<li><strong>HOMING: </strong>An interactive sound art work, Homing explores how media can be conveyed in a small geographic area. Created by artists Jen Southern and Sam Thulin alongside the Media Innovation Studio, the installation, based in Preston\u2019s central square, takes the original letters of soldiers in WW1, and presents them in digital form to users as they approach the cenotaph. Depending on location, a sound composition from the cemeteries at the Somme can be heard, with all the sensory qualities of the local conditions; wind, rain, whistling, stonework. Out on the Flag Market, these sounds give way to fragments of stories from the men in the trenches. Homing uses sound to make connections at a distance; between presence and absence, people and place, displacement and home.</li>\r\n</ul>\r\n<h3><strong><img class=\"aligncenter wp-image-10777 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/mis1.jpg\" alt=\"\" width=\"630\" height=\"632\" /></strong></h3>\r\n<h3><strong>The future</strong></h3>\r\nWorking in innovation, Mills suggests it\u2019s difficult to predict specifically what the next 12 months will bring. However, he is certain that industry, academic and community partnerships will form a substantial part of it. Previous projects have involved SMEs, regional publishing groups such as Trinity Mirror and Johnston Press, national publishers such as Haymarket Media, hyperlocal media and independent production companies. In addition to these industry partnerships, the centre\u2019s research has also involved a breadth of community groups and institutions.\r\n<blockquote>\u201cThe last five years has been both challenging and exciting, and our partnerships \u2013 which range from local schools and museums to international publishing houses \u2013 are key to our activities. We\u2019ll continue to develop concepts, ideas and research via disruptive and emergent technology. We hope to make a positive contribution to both journalism and the media more generally,\u201d Mills explains.</blockquote>\r\nHe expects that future projects will span IoT, augmented print, proximity broadcasting and areas that are yet to be imagined.\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT:\r\n\r\n<img class=\"alignnone wp-image-10701\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/john-mills-285x300.png\" alt=\"\" width=\"200\" height=\"256\" />\r\n\r\nJohn Mills, Lecturer and Researcher, Media Innovation Studio\r\nWeb: <a href=\"http://mediainnovationstudio.org/\" target=\"_blank\" rel=\"noopener noreferrer\">http://mediainnovationstudio.org/</a>\r\nTwitter: <a href=\"https://twitter.com/_johnmills\" target=\"_blank\" rel=\"noopener noreferrer\">@_johnmills</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Media Innovation Studio: international research, creative methods and multidisciplinary approaches","post_link":"https://media-innovation.news/media-lab/media-innovation-studio-international-research-creative-methods-multidisciplinary-approaches/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Media Innovation Studio: international research, creative methods and multidisciplinary approaches\" width=\"300\" height=\"144\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/mis3.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"3D manufacturing, academic Lab, academic research, creative methods, data journalism, drone journalism, international research, multidisciplinary, prototypes, UK","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1526999766:101","%_edit_last%":"1","%_thumbnail_id%":"10779","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_focuskw_text_input%":"Media Innovation Studio","%_yoast_wpseo_focuskw%":"Media Innovation Studio","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%_wpgmp_location_address%":"University of Central Lancashire, Preston, United Kingdom","%_wpgmp_metabox_latitude%":"53.7645034","%_wpgmp_metabox_longitude%":"-2.7083505000000514","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545276518,"payload":[{"id":9934},{"id":11024},{"id":10119}]}},"taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"3D manufacturing, academic Lab, academic research, creative methods, data journalism, drone journalism, international research, multidisciplinary, prototypes, UK"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10776,"infowindow_disable":false},{"source":"post","title":"Media Lab Bayern: an incubation unit for digital media development and innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Media Lab Bayern: an incubation unit for digital media development and innovation\" width=\"300\" height=\"132\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/bayern-media-lab-300x132.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Media Lab Bayern: an incubation unit for digital media development and innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Focused on digital journalism innovation, Media Lab Bayern is a co-working incubation unit for media innovation startup companies which provides journalism and entrepreneurship aid and coaching for media development.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/media-lab-bayern-an-incubation-unit-for-digital-media-development-and-innovation/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Focused on digital journalism innovation, Media Lab Bayern is a co-working incubation unit for media innovation startup companies which provides journalism and entrepreneurship aid and coaching for media development.","address":"Munich, Germany","location":{"lat":"48.1351253","lng":"11.581980499999986","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/media-lab-bayern-an-incubation-unit-for-digital-media-development-and-innovation/","zoom":2,"extra_fields":{"post_excerpt":"Focused on digital journalism innovation, Media Lab Bayern is a co-working incubation unit for media innovation startup companies which provides journalism and entrepreneurship aid and coaching for media development.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Media Lab Bayern: an incubation unit\u00a0for\u00a0digital media\u00a0development and innovation</h1>\r\n<strong>Located in Munich, the Media Lab Bayern is a co-working and incubation space dedicated to media innovation startup companies. Focused on enhancing digital journalism and developing media projects, the Lab uses a multidisciplinary approach to encourage and support the evolution of projects from the initial idea to the foundation and launch of a start-up company.\r\n</strong>\r\n\r\nThe media lab was created in 2015 to foster media innovation, \u201cto bring together [multidisciplinary] teams and to support entrepreneurship in media,\u201d explains Lina Timm, director of Media Lab Bayern.<strong>\u00a0</strong>\r\n\r\nThe lab provides a creative and supportive space for startups, offering aid and advice for teams developing media innovation project ideas. It is aimed at both students and professionals from the media, journalism, information technology, design and business development sectors.\r\n<h3>Methods</h3>\r\nThe lab employs a variety of approaches to foster and develop media innovation ideas from inception to market launch, mainly focusing on design thinking and lean development. After thorough analysis of every team\u2019s needs, these methods are then taught to candidates and future company owners during three programmes tailored for specific needs and targets.\r\n\r\nThese programmes are:\r\n<ul>\r\n\t<li>Open-space programme: a co-working space allowing teams selected by the Media Lab to work on project ideas related to innovation and media with coaching from specific mentors brought in by the lab</li>\r\n\t<li>Media entrepreneurship programme: a three month long design thinking course which focuses on identifying trends, researching how the audience approaches media and doing research on issues within the media industry and provides aid for people without teams and/or with rough project ideas</li>\r\n\t<li>Media Startup Fellowship: a six month long incubation programme which offers mentoring, business coaching and financial aid of up to \u20ac15.000 to launch a product or company on the market</li>\r\n</ul>\r\nThe lab also organises Hackathons, two-day events which bring together teams journalists, programmers and web design to develop new ideas, concepts and prototypes which are then evaluated by a jury.\r\n<h3><img class=\"aligncenter wp-image-10772 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/media-lab-bayern-4.jpg\" alt=\"\" width=\"800\" height=\"533\" /></h3>\r\n<h3>Metrics</h3>\r\nAs the unit is focused on supporting and mentoring teams to develop project ideas and startup companies, Media Lab Bayern measures their success through analysing the number of companies launched during or after the startup fellowship.\r\n\r\nOther metrics used to evaluate the success of the media lab are the number of attendees in the three programmes offered, the popularity of the events organised and results of the startups incubated within the lab after their launch on the market.\r\n\r\nThe lab is currently looking into developing additional metrics to assess the lab\u2019s success more effectively and to continue to enhance the lab based on these results.\r\n<h3>Partners</h3>\r\nMedia Lab Bayern is affiliated with the Ministry of Economics and the Regional Ministry, who provide the majority of funds for their projects, as well as the Bavaria Regulatory Authority for New Media.\r\n\r\nDue to the collaborative method of work, the Lab maintains strong connections with a variety of media and business experts from Bavaria, who are often brought in as mentors to offer advice to the teams participating in the Lab\u2019s programmes, as well as supervise their activities.\r\n\r\nThe relationships with developing and design partners is also maintained through the Hackathon events organised by the Media Lab Bayern. The events allows the Lab to connect experts from various domains, including journalism, business and computer science, with teams signed up for one of the three programmes offered by the Lab, in order to broaden the collaboration network.\r\n\r\nIn addition, the Media Lab often collaborates with Red Bull Media House on various projects dedicated to media innovation.\r\n<blockquote>\u201cI\u2019m constantly trying to be open my network from media companies, publishers, from broadcasters, radio stations, everyone who\u2019s in a big company in media in Germany, gets to help our teams to get first customers or to get a test project or something with the others,\u201d says Timm.</blockquote>\r\n<h3>Projects</h3>\r\nOne of Media Lab Bayern\u2019s most successful projects is the launch of <a href=\"http://vanishtale.com/#/home/home\">VanishTale</a>, a startup company producing Snapchat stories, videos and features for publishers and brands.\r\n\r\nThe company also develops marketing strategies and guidelines for brands, as well as provides data relating to audience engagement with content, growth rates and content analysis.\r\n\r\nVanishTale was formed as a collaboration between two participants in the lab\u2019s open space programme after their individual teams got disbanded. The two approached different project ideas throughout the startup fellowship until settling for their Snapchat marketing developer company, and continued to develop it through the Axel Springer Plug and Play Accelerator.\r\n<blockquote>\u201cFor me, this is a really huge success, even if they\u2019re not uniform yet. It\u2019s my favourite team because they paved a path, they did their homework, I think they really learned the tool sets, how to do innovation, how to give up another idea, and they worked together as a team, so I\u2019m really proud of them,\u201d says Timm.</blockquote>\r\nAnother project conducted by Bayern is <a href=\"http://medialab-bayern.de/futurelab/\">FutureLab</a>, an event which consists of five workshops and one Hackathon where 10 partners discuss themes concerning:\r\n<ul>\r\n\t<li>Smart Mobility</li>\r\n\t<li>Wearables</li>\r\n\t<li>Smart Homes</li>\r\n\t<li>Artificial Intelligence</li>\r\n\t<li>Augmented Reality</li>\r\n</ul>\r\nThe participating partners include Lufthansa, Red Bull Media House, ASUS and IBM Watson.\r\n<h3>Looking to the future</h3>\r\nMedia Lab Bayern will continue to provide counseling and funding for developing startup companies in the near future, as well as organise Hackathons and other events. The team will also continue to further broaden their media network to improve their services and increase the number of mentors available for consultancy.\r\n\r\nIn addition, the lab is planning to attend a number of conferences on media innovation, such as Media Days in October, and organise innovation tracks starting this autumn.\r\n\r\n\u201cWe have so many things that I don\u2019t know when to do all them, but it\u2019s going to be cool!\u201d says Timm.\r\n\r\nCONTACT POINT:\r\n\r\n<img class=\"alignnone size-medium wp-image-10770\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/lina-timm-2-200x300.jpg\" alt=\"\" width=\"200\" height=\"300\" />\r\n\r\nLina Timm, Director, Media Lab Bayern\r\nWeb: <a href=\"http://medialab-bayern.de/\" target=\"_blank\" rel=\"noopener noreferrer\">http://medialab-bayern.de/</a>\r\nTwitter: <a href=\"https://twitter.com/Luisante\" target=\"_blank\" rel=\"noopener noreferrer\">@Luisante</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Media Lab Bayern: an incubation unit for digital media development and innovation","post_link":"https://media-innovation.news/media-lab/media-lab-bayern-an-incubation-unit-for-digital-media-development-and-innovation/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Media Lab Bayern: an incubation unit for digital media development and innovation\" width=\"300\" height=\"132\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/bayern-media-lab-300x132.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"business coaching, design thinking, funding, Germany, Hackathon, incubator, lean development, prototypes, startups","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527003093:101","%_oembed_d7d82d90ba5a6931fed5bda13ec25713%":"{{unknown}}","%_edit_last%":"101","%_thumbnail_id%":"10756","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_focuskw_text_input%":"Media Lab Bayern","%_yoast_wpseo_focuskw%":"Media Lab Bayern","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%_wpgmp_location_address%":"Munich, Germany","%_wpgmp_metabox_latitude%":"48.1351253","%_wpgmp_metabox_longitude%":"11.581980499999986","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545519556,"payload":[{"id":10681},{"id":10942},{"id":10754}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"business coaching, design thinking, funding, Germany, Hackathon, incubator, lean development, prototypes, startups"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10766,"infowindow_disable":false},{"source":"post","title":"University of Vienna MiLab: innovating media through academic research","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Vienna MiLab: innovating media through academic research\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/MiLab-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Vienna MiLab: innovating media through academic research</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            University of Vienna's Media Innovation Lab (MiLab) is a research-based unit which examines the development of new media technologies and evolution of media innovation, while also analysing the impact new media has on the public and society.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/university-vienna-milab-innovating-media-academic-research/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"University of Vienna's Media Innovation Lab (MiLab) is a research-based unit which examines the development of new media technologies and evolution of media innovation, while also analysing the impact new media has on the public and society.","address":"University of Vienna, Universit\u00e4tsring, Vienna, Austria","location":{"lat":"48.21318549999999","lng":"16.360050399999977","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/university-vienna-milab-innovating-media-academic-research/","zoom":2,"extra_fields":{"post_excerpt":"University of Vienna's Media Innovation Lab (MiLab) is a research-based unit which examines the development of new media technologies and evolution of media innovation, while also analysing the impact new media has on the public and society.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1><strong>University of Vienna MiLab: innovating media through academic research</strong></h1>\r\n<strong>This research-based unit examines the development of new media technologies and evolution of media innovation, while also analysing the impact new media has on the public and society.</strong>\r\n\r\nLocated in the capital of Austria, Media Innovation Lab of the University of Vienna researches new media technologies and their impact on the current media, society and users. The lab was created to analyse and examine the effects new tech on the public, and how technology can be studied at the intersection between society, psychology and politics.\r\n\r\n\u201cTo MiLab, innovation represents a core basic part of journalism and civic society. Innovation goes hand-in-hand with the way citizens use media and may form an informed public opinion. Thus, innovation is inherent to change and progress,\u201d says Dr Homero Gil de Zu\u00f1iga Navajas, Director of the Media Innovation Lab.\r\n<h3>Methodology</h3>\r\nMiLab publishes academic research papers across social sciences disciplines that investigates the impact of technologies, asking \u201cwhat do people do with this, how it can change people\u2019s lives. So we\u2019re working a bit differently,\u201d said Homero Gil de Zu\u00f1iga Navajas, director of the Media Innovations Lab.\r\n\r\nThe lab uses an interdisciplinary approach to conduct research and focus on survey data to generate information. The team, consisting of Homero Gil de Zu\u00f1iga Navajas together with two post-doctoral researchers and two doctoral students, examines the data to determine the impact of new technologies and media innovation on various aspects of society life.\r\n\r\nThe aim of the team is to influence industry, academia and policymakers in meeting the demands digital technology places on society.\r\n<h3>Projects</h3>\r\nMiLab\u2019s work revolves around academic publications on research ranging from political communication to journalism, media innovation and many other themes.\r\n<blockquote>\u201cRather than just innovating in the sense of \u2018let\u2019s generate a new app that we will use for this and that\u2019, we are more interested in all disruptive changes that are taking place right now and how are those technologies affecting both journalism and society at large.\u201d</blockquote>\r\nMiLab\u2019s outputs cover a multitude of themes, such as \u201cSecond Screening Politics in the Social Media Sphere: Advancing Research on Dual Screen Use in Political Communication\u201d, published in the <a href=\"http://www.tandfonline.com/loi/hbem20\" target=\"_blank\" rel=\"noopener noreferrer\">Journal of Broadcasting &amp; Electronic Media</a>, \u201c<a href=\"http://journals.sagepub.com/doi/full/10.1177/0894439315619589\">Citizenship, Social Media and Big Data: Current and Future Research in the Social Sciences</a>, published in the <a href=\"http://journals.sagepub.com/home/ssc\" target=\"_blank\" rel=\"noopener noreferrer\"><em>Social Science Computer Review.</em></a>\r\n<h3>Collaborations</h3>\r\nMiLab maintains strong connections with other academic media innovation labs across the globe, often collaborating on research projects on various themes revolving media innovation and its impact on society.\r\n\r\nSome of MiLab\u2019s partners include Princeton University, Universidad Diego Portales (Chile), University of California (Santa Barbara), Universidad de Monterey (Mexico) and many others.\r\n\r\nIn addition, the Media Innovation Lab is currently working in partnership with Massey University in New Zealand on the World Digital Influence Project. Together with other researchers across the globe, the project focuses on the ways people are using technology, their level of engagement in politics and the characteristics of how they are approaching new information and the media in general.\r\n<blockquote>\u201cConnections usually come more from people, rather than just \u2018We have to start with this lab, let\u2019s seek out what other labs are out there and try to collect information\u2019. They are connections that take place from collaborations that happened between people or interests, or you know them from conferences or you read their work and they read your work and eventually, some of these collaborations just take part.\"</blockquote>\r\n<h3>Future</h3>\r\nWith the digital world evolving rapidly around us, Gil de Zu\u00f1iga Navajas feels there are key elements that will influence society, and therefore his research.\r\n<blockquote>\u201cIt is very likely the main area of progress relates to artificial intelligence. Self-learning machines will not only affect the way information is produced and disseminated, they will also affect the very understanding of what it is to be a functional citizen in modern society.\u201d</blockquote>\r\nIn terms of projects, the Lab is currently bidding for another grant which will be used to fund research targeting mental reality. This is defined as the characteristics of information consumption using technological devices and the cognitive differences in terms of information recognition and memory recall.\r\n<blockquote>\u201cIf the grant is successful we will be able to learn more about the influence of digital media, virtual reality and other new technologies in the field of journalism. We will also be able to learn more about how young people get civically socialized in the European Union. What is to be a good citizen to them? How to they engage in civic activities?\u201d</blockquote>\r\nThe team will also continue their collaborative work with Massey University and the other global partners for the World Digital Influence Project, which will span out for the next three years and which will continue to inspect the public\u2019s technology use and interaction with politics, information and media.\r\n\r\nIn addition, MiLab is looking at the possibility of expanding studies and conducting more experiments to compare two different methods of receiving news information: through mental reality versus through traditional ways (i.e. watching television).\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-10729 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/MiLabHomero.jpeg\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nDr Homero Gil de Zu\u00f1iga Navajas, Director of the Media Innovation Lab\r\nWeb: <a href=\"http://milab.univie.ac.at/\" target=\"_blank\" rel=\"noopener noreferrer\">http://milab.univie.ac.at/</a>\r\nTwitter: <a href=\"https://twitter.com/univienna\" target=\"_blank\" rel=\"noopener noreferrer\">@univienna</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"University of Vienna MiLab: innovating media through academic research","post_link":"https://media-innovation.news/media-lab/university-vienna-milab-innovating-media-academic-research/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Vienna MiLab: innovating media through academic research\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/MiLab-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic research, Austria, media technologies, political communication, survey data","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527003130:101","%_edit_last%":"101","%_thumbnail_id%":"10689","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_hide_info%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_focuskw_text_input%":"MiLab","%_yoast_wpseo_focuskw%":"MiLab","%_yoast_wpseo_linkdex%":"68","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_kleo_title_checkbox%":"1","%_wpgmp_location_address%":"University of Vienna, Universit\u00e4tsring, Vienna, Austria","%_wpgmp_metabox_latitude%":"48.21318549999999","%_wpgmp_metabox_longitude%":"16.360050399999977","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545524378,"payload":[{"id":10681},{"id":11024},{"id":10942}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic research, Austria, media technologies, political communication, survey data"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10686,"infowindow_disable":false},{"source":"post","title":"Arizona State University New Media Innovation and Entrepreneurship Lab: cutting-edge media innovation through app development","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Arizona State University New Media Innovation and Entrepreneurship Lab: cutting-edge media innovation through app development\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/asu-media-lab-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Arizona State University New Media Innovation and Entrepreneurship Lab: cutting-edge media innovation through app development</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Arizona State University New Media Innovation and Entrepreneurship Lab is a research and development unit which focuses on producing cutting-edge products for media companies and educating students from various departments to enhance the regional and national media system.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/10754/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Arizona State University New Media Innovation and Entrepreneurship Lab is a research and development unit which focuses on producing cutting-edge products for media companies and educating students from various departments to enhance the regional and national media system.","address":"Walter Cronkite School of Journalism and Mass Communication, North Central Avenue, Phoenix, AZ, United States","location":{"lat":"33.4537558","lng":"-112.07318809999998","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/10754/","zoom":2,"extra_fields":{"post_excerpt":"Arizona State University New Media Innovation and Entrepreneurship Lab is a research and development unit which focuses on producing cutting-edge products for media companies and educating students from various departments to enhance the regional and national media system.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1><strong>Arizona State University New Media Innovation and Entrepreneurship Lab: cutting-edge media innovation through app development</strong></h1>\r\n&nbsp;\r\n\r\n<strong>Located in Walter Cronkite School of Journalism and Mass Communication, Arizona State University\u2019s New Media Innovation and Entrepreneurship Lab is a multidisciplinary research and development centre focused on software application development. The Lab brings people from journalism, computer science, graphic design and business to study and produce innovative digital media products to improve the standards of reporting for regional and national press.</strong>\r\n\r\nConceived to provide a different and innovative way of teaching journalism, the lab was created in 2007 at the initiative of the Dean of the Walter Cronkite School of Journalism and Mass Communication, Christopher Callahan, and the President of the Arizona State University.\r\n\r\nRetha Hill, director of the New Media Innovation and Entrepreneurship Lab since August 2007, describes their mission is to do research and development for the news media industry. The lab is conducting surveys and studies and provides clients who hire the lab for various commissions with information, prototypes or finished products.\r\n\r\nIn addition, the Lab team, which includes Hill, two part-time journalism students, a full time developer and two part-time computer science students, seeks to develop \u201cdifferent new media applications that legacy media could use to reach a new generation or different people.\u201d\r\n\r\n\u201cPosing a questions, seeing if you can get answers to that question and then testing; that\u2019s what our lab does for the most part.\u201d\r\n\r\nThe Media Innovation Lab also focuses on educating students from all departments, including journalism, computer science and business, and developing any business or media plans for startup companies brought in by students.\r\n\r\nHill outlines a multidisciplinary educational process which combines journalism, product development and business principles, resulting in the launch of \u201ca minimally viable product, a lead startup canvas or an outline of a business plan\u201d based on student initiative and ideas.\r\n<h3>Partners</h3>\r\nThe Media Lab maintains connections with Gannett the largest news company in North America as well as other previous clients who have commissioned work, These include Arizona Republic newspaper, CityScape and State of Arizona\u2019s Parks and Recreation Division.\r\n\r\nThe Lab also remains in contact with other organisations from whom they receive grants, including Knight News Foundation and the Women Entrepreneurship Foundation.\r\n\r\nAlthough there are no direct collaborations, the New Media Innovation and Entrepreneurship Lab maintains relations with other media innovation labs across the US and world, including the Media Innovation Lab at the University of North Carolina and Knight Lab at Northwestern University. The labs often meet at conferences, including the annual Online News Association Conference, and share information and data about their projects.\r\n<h3>Projects</h3>\r\nSince its inception the Lab has produced various products, including mobile phone and website applications, software and augmented and virtual reality applications.\r\n\r\nFocused on providing students with as many learning opportunities as possible, Hill says she \u201cdoes not take on projects that are repetitive,\u201d and pursues new projects to remain cutting edge.\r\n\r\nSome of the projects that the Lab has worked on include:\r\n<ul>\r\n\t<li><a href=\"https://itunes.apple.com/us/app/on-time-phx/id987630365?mt=8\">OnTime PHX</a>: a real-time iPhone and Apple Watch application which provides user with accurate information about the Phoenix Valley Metro light rail train locations and schedules</li>\r\n\t<li><a href=\"http://azfiretracker.azcentral.com/\">Wildfire tracker</a>: a website application created for the Arizona Republic newspaper, which provides maps and data of previous wildfires in the state and tracks any current wildfires in the area</li>\r\n\t<li>Playable Media Story Engine: a plugin for WordPress and WordPress mobile which allows journalists to rapidly design and produce interactive narrative news stories based on a combination of journalism and gaming principles and methods</li>\r\n\t<li><a href=\"https://backhome.news21.com/article/va-game/?lipi=urn%3Ali%3Apage%3Ad_flagship3_profile_view_base%3Bc04enog5Rka0L7eE0OvGog%3D%3D\">VA Newsgame</a>: the \u201cCan you make it in the VA?\u201d game was created, in partnership with the university\u2019s Centre for Games &amp; Impact, as an interactive element for a national reporting initiative focused on issues facing Iraq and Afghanistan war veterans</li>\r\n\t<li>Black History AR Mobile App: an augmented reality mobile app which focuses on presenting users facts about black history in cities across America</li>\r\n</ul>\r\nOther previous projects include a hiking app for the state of Arizona\u2019s Parks and Recreation Department, providing data on hiking trails, potential dangers and other useful info, a digital city guide for Queen Creek, Arizona, and an app for the Society of Baseball Research which locates baseball attractions in all MLB cities.\r\n\r\nIn addition, the New Media Innovation and Entrepreneurship Lab has helped build various media companies launched by students, including the <a href=\"http://azcir.org/\">Arizona Centre for Investigative Reporting</a>, and Terrainial, a company which focuses on 360/VR immersive storytelling.\r\n<h3>Future</h3>\r\nThe New Media Innovation and Entrepreneurship Lab will continue throughout the next months developing the Playable Media Story Engine project, which is currently on-going.\r\n\r\nThe team is also looking into pursuing projects focused around hololens and creating applications for Oculus Rift or HTC Vive, as well as continue to pursue projects involving mixed and augmented reality.\r\n\r\n\u201cI often try to do cutting edge things, get out ahead of the curve so we can have those learnings as opposed to waiting until something has pretty much saturated the market.\u201d\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT:\r\n\r\n<img class=\"alignnone size-medium wp-image-10761\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/retha-hill-full-240x300.jpg\" alt=\"\" width=\"240\" height=\"300\" />\r\n\r\nRetha Hill\r\n\r\nLinkedIn: https://www.linkedin.com/in/rethahill/\r\n\r\nTwitter: @rethahill[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Arizona State University New Media Innovation and Entrepreneurship Lab: cutting-edge media innovation through app development","post_link":"https://media-innovation.news/media-lab/10754/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Arizona State University New Media Innovation and Entrepreneurship Lab: cutting-edge media innovation through app development\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/asu-media-lab-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic Lab, applications, entrepreneurship, gaming, Knight Foundation, prototypes, software, USA, virtual reality, Women Entrepreneurship Foundation","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527003164:101","%_edit_last%":"101","%_thumbnail_id%":"10755","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_focuskw_text_input%":"media innovation","%_yoast_wpseo_focuskw%":"media innovation","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_wpgmp_location_address%":"Walter Cronkite School of Journalism and Mass Communication, North Central Avenue, Phoenix, AZ, United States","%_wpgmp_metabox_latitude%":"33.4537558","%_wpgmp_metabox_longitude%":"-112.07318809999998","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545450305,"payload":[{"id":10942},{"id":11024},{"id":11362}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic Lab, applications, entrepreneurship, gaming, Knight Foundation, prototypes, software, USA, virtual reality, Women Entrepreneurship Foundation"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10754,"infowindow_disable":false},{"source":"post","title":"BBC News Labs: collaborative unit for media innovation and product development","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"BBC News Labs: collaborative unit for media innovation and product development\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/babelsoperator-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">BBC News Labs: collaborative unit for media innovation and product development</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            BBC News Labs is a collaborative, multi-disciplinary unit which focuses on developing digital innovation tools to solve issues within the media and improve news content.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/bbc-news-labs-collaborative-unit-for-media-innovation-and-product-development/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"BBC News Labs is a collaborative, multi-disciplinary unit which focuses on developing digital innovation tools to solve issues within the media and improve news content.","address":"BBC Nottingham / BBC East Midlands, London Road, West Bridgford, United Kingdom","location":{"lat":"52.9496608","lng":"-1.1400241999999707","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/bbc-news-labs-collaborative-unit-for-media-innovation-and-product-development/","zoom":2,"extra_fields":{"post_excerpt":"BBC News Labs is a collaborative, multi-disciplinary unit which focuses on developing digital innovation tools to solve issues within the media and improve news content.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1><strong>BBC News Labs: collaborative unit for media innovation and product development</strong></h1>\r\n<strong>Focused on speed and thorough analysis, BBC News Labs fosters and develops innovation in order to solve problems encountered by journalists in newsrooms, and research broader themes in media innovation.</strong>\r\n\r\nThe BBC News Labs was created in 2012 as part of Connected Studio, the pan-BBC Innovation Programme. Part of the world\u2019s largest broadcasting media organisation, it is a multi-disciplinary unit dedicated towards creating and developing projects in journalism, technology and data.\r\n\r\nIts goal is to assess new technologies and evaluate their potential use within BBC News and media in general. The lab also analyses tech made either inside the BBC or outside it and keeps a strong connection between different departments within the BBC, including BBC Engineering and BBC Research and Development.\r\n<h3>Partnerships and collaborations</h3>\r\nThe Lab maintains strong connections between the BBC and other external organisations, academic institutions and other media labs: \u201cNews Labs is a genuine partnership, and one of the reasons why we sat in a pan-BBC organisation is because we are genuinely co-funded and genuinely a collaboration between different BBC departments.\u201d\r\n\r\nBBC News Labs partners with other departments within the news organisation, including BBC Research and Development, BBC Engineering and BBC Connective Studio. Together, all these departments analyse potential projects for software or prototypes and change them in order to fit the needs of journalists and improve the quality of news content provided by the BBC.\r\n<blockquote>\u201cThe great thing about that is that we act as a bridge, so we\u2019ll provide two-way traffic between those three bits of the BBC that wouldn\u2019t normally talk much to each other, but in my opinion need to talk to each other,\u201d said Robert McKenzie, editor at the News Labs. \u201cIt\u2019s about building links with academia and with other parts of the industry to make sure that at a time of huge change the BBC was part of the more generalised, news and academic news thinking.\u201d</blockquote>\r\nThe primary contact strategy used by BBC News Labs in order to establish and maintain connections and collaborations with external partners is <a href=\"http://bbcnewslabs.co.uk/projects/news-hack/\" target=\"_blank\" rel=\"noopener noreferrer\">#newsHACK</a>, which is a two-day event organised by the BBC News Labs, bringing together teams of news organisations members, academics and students to discuss common issues in today\u2019s media and find solutions for each problem raised.\r\n\r\nIn terms of connectivity with academia and students, BBC News Labs organises a special event called the University Challenge, in which journalism and computer engineer students from universities well-known for their journalism departments, work together as a team (one journalism student and one computer engineer student in a joint team) to solve a specific problem that targets both domains.\r\n<h3>Projects</h3>\r\nOne of the projects that was launched partly thanks to the Challenge event is <a href=\"https://media-innovation.news/media-lab/inject-a-european-journalism-and-technology-project-building-creativity-tools-for-journalists/\" target=\"_blank\" rel=\"noopener noreferrer\">INJECT</a>, a project initiated by professors from different departments within City University London, which focuses on developing digital creativity tools to improve the quality of news content.\r\n\r\nThe INJECT project brings together 14 partners from Norway, Greece, Netherlands, France, Germany and the United Kingdom and targets transferring new digital technologies to news organisations to improve the creativity and the productivity of journalists, in order to increase the competitiveness of European news and media organisations.\r\n\r\nThe project, worth over \u20ac1 million, has received a grant from the European Commission\u2019s Horizon 2020 and was launched in January 2017.\r\n\r\nLooking at other work, one of BBC News Labs\u2019 successful internal projects was the News Switcher software, currently incorporated into the organisation\u2019s Content Production System. The Internet-based software allows BBC journalists in newsrooms to view the online versions of the BBC News website based on the desired device (mobile, tablet, laptop/PC) and desired country or area of publication and optimise the content published for those version.\r\n\r\n<span style=\"color: #000000; font-family: Calibri;\"><img class=\"aligncenter wp-image-10674 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/news_switcher.png\" alt=\"\" width=\"1185\" height=\"642\" /></span>\r\n\r\nOther projects, which are currently being developed by the 15-member team, include Speech-to-Text software, Content Analysis Toolkit, which includes research into software and prototypes for facial recognition, voice recognition and text analysis, and the Object-based media project.\r\n\r\nObject-based media focuses on transforming audio and video content into \u201cobjects\u201d and tailoring the material sent to the public based on the technological capacities and qualities of the device on which the material is viewed on. Robert McKenzie gives more details about the project:\r\n<blockquote>\u201cAt the moment, when you\u2019re putting together a radio or TV package, you assemble all the elements in an edit suite or on your desktop PC, you put all the bits together: the video, the graphics, the audio edits, the sound effects, the grading, the subtitles, everything else, you put it all together and you tie it up in a neat little, what effectively becomes a flat file. Object-based media takes the complete opposite approach.\u201d</blockquote>\r\nHe suggests that editors will \u201cstill assemble everything in their edit suite or desktop computer, but each individual element of that will be an \u2018object\u2019\u201d. This means that the decisions on the sound effects, the quality of pictures and others will be dependent on the device that it\u2019s being displayed on.\r\n\r\nMcKenzie explains that if \u201cyour device says \u2018I\u2019m a big, ultra high-definition television, 55 inches wide with a surround sound system in someone\u2019s man-cave, so I\u2019m going to take the ultra-high definition list with the amazing graphics and the fabulous sound effects and the surround sound and all the colours and the textures the BBC can possibly do.\r\n<blockquote>\u201cBut if you send that programme to somebody else standing outside on their mobile phone and it says \u2018Oh, I\u2019m a mobile phone on a 3G connection, I can\u2019t see half these colours, I can\u2019t hear any of those sound effects, I don\u2019t need the grading, but I do need subtitles\u2019, it will assemble itself according to what your device is capable of dealing with.\u201d</blockquote>\r\n<h3>Looking to the Future</h3>\r\nMcKenzie doesn\u2019t have strict deliverables and the Lab has the freedom and flexibility to explore a multitude of projects over the next year. However, he does predict that BBC News Labs will continue their work on their on-going projects and particularly focus on developments around object-based media.\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-10675 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/Rob-profile-pic-e1496485804553.jpg\" alt=\"\" width=\"158\" height=\"199\" />\r\n\r\nRobert McKenzie, Editor, BBC News Media Lab\r\nWeb: <a href=\"http://bbcnewslabs.co.uk/\">http://bbcnewslabs.co.uk/</a>\r\nTwitter: <a href=\"https://twitter.com/BBC_NEWS_LABS\">@BBC_News_Labs</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"BBC News Labs: collaborative unit for media innovation and product development","post_link":"https://media-innovation.news/media-lab/bbc-news-labs-collaborative-unit-for-media-innovation-and-product-development/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"BBC News Labs: collaborative unit for media innovation and product development\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/babelsoperator-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic collaboration, digital creativity, Hackathon, horizon 2020, internal innovation, media organisation, multidisciplinary, object-based media, partnerships, personalisation, prototypes, UK","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527003062:101","%_edit_last%":"101","%_thumbnail_id%":"10676","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_focuskw_text_input%":"BBC News Labs","%_yoast_wpseo_focuskw%":"BBC News Labs","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_kleo_title_checkbox%":"1","%_wpgmp_location_address%":"BBC Nottingham / BBC East Midlands, London Road, West Bridgford, United Kingdom","%_wpgmp_metabox_latitude%":"52.9496608","%_wpgmp_metabox_longitude%":"-1.1400241999999707","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545365401,"payload":[{"id":10681},{"id":10766},{"id":10686}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic collaboration, digital creativity, Hackathon, horizon 2020, internal innovation, media organisation, multidisciplinary, object-based media, partnerships, personalisation, prototypes, UK"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10673,"infowindow_disable":false},{"source":"post","title":"University of Kansas Media Innovation Lab: bringing students, professors and industries together for media innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Kansas Media Innovation Lab: bringing students, professors and industries together for media innovation\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/kansas-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Kansas Media Innovation Lab: bringing students, professors and industries together for media innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            University of Kansas Media Innovation Lab is a multi-disciplinary lab which combines academic research with digital product development and teaching in order to foster media innovation, as well as help develop new project ideas.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/university-kansas-media-innovation-lab-bringing-students-professors-industries-together-media-innovation/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"University of Kansas Media Innovation Lab is a multi-disciplinary lab which combines academic research with digital product development and teaching in order to foster media innovation, as well as help develop new project ideas.","address":"William Allen White Elementary School, Exchange Street, Emporia, KS, United States","location":{"lat":"38.4091868","lng":"-96.17462069999999","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/university-kansas-media-innovation-lab-bringing-students-professors-industries-together-media-innovation/","zoom":2,"extra_fields":{"post_excerpt":"University of Kansas Media Innovation Lab is a multi-disciplinary lab which combines academic research with digital product development and teaching in order to foster media innovation, as well as help develop new project ideas.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1><strong>University of Kansas Media Innovation Lab: bringing students, professors and industries together for media innovation </strong></h1>\r\n<strong>The lab, which incorporates students, faculty members and other external organisations, combines teaching, research and production of projects. It provides both support and advice for project ideas and prototypes that target issues in the contemporary media.</strong>\r\n\r\nThe Media Innovation Lab was launched in 2011 by Michael Williams, Director of the lab, after completing a three-year stint as Chair of the News and Information track at the University of Kansas. Located in the William Allen White School of Journalism and Mass Communications, University of Kansas\u2019s Media Innovation Lab is a \u201cproject-level research lab\u201d which focuses on studying, developing and creating new tools and solutions for media innovation.\r\n\r\nIts goal is to upgrade and update the university\u2019s journalism courses and to teach students journalism based on current society and industry trends. \u201cWe\u2019ve got to quit worrying about teaching 1980 journalism and really start to think about what we\u2019re going to do in 2020,\u201d said Williams.\r\n\r\nThanks to funding of approximately $50.000, collected from university investments and research grants from the Knight Foundation, the Media Innovation Lab was built as a research facility focused on turning projects from ideas into reality by providing aid, advice and support for their development.\r\n\r\nThose students who go through the lab work out of the university\u2019s Information and Telecommunications Technology Centre ITTC and encounter a range of disciplines \u201cin an independent space and organisation in the sense that it isn\u2019t directly tied to an academic unit\u201d.\r\n<blockquote>\u201cThe lab is there as a place to find mentors, a place to get guidance towards funding and that sort of thing and so, in many ways we could call it the catalyst as much as a lab and that\u2019s kind of where we\u2019ve gone with it.\u201d</blockquote>\r\nThe lab is also intertwined with a Media Innovation class for the undergraduate journalism course dedicated towards getting students interested in thinking innovatively about media questions and issues.\r\n<h3>Partnerships/collaborations</h3>\r\nInitially just a small department with only four journalism faculty members as the core team, the Lab has steadily grown into a multidisciplinary and collaborative conglomerate through connections with students, academics and other external organisations.\r\n\r\nThe Media Innovation Lab has strong ties with many academic departments within the University of Kansas, including the Sociology, Psychology and Engineering departments, often bringing professors from these faculties as mentors and working on joint projects that revolve around all areas of study. Undergraduate and graduate students from various university departments are also a core and constant part of the media lab, who work for project ideas started by either the unit or their own ideas out of the ITTC centre, which is the largest research centre in the University of Kansas..\r\n\r\nThe Media Innovation Lab often collaborates with other external startup industries in Kansas City, including the Kansas City Tech Council.\r\n<blockquote>\u201cIt\u2019s a cluster of collaborators: two or three of us in the journalism faculty frequently get together, just sort of imagining what\u2019s next, another larger circle around that group that includes folks from the computer side and engineering area, the psych folk, the sociology folks.\u201d</blockquote>\r\nWilliams suggests this network of collaboration is an intersecting Venn diagram that includes \u201cfriends and colleagues in some of the startups and bigger industries over the Kansas City area that I know I can call and say \u2018Hey, you know, I\u2019ve got somebody that wants to do something like this, what do you think?\u2019 and there\u2019s two or three organisations over there.\u201d\r\n<h3>Projects</h3>\r\nOne of University of Kansas Media Innovation Lab\u2019s successful projects is the Avershield software, launched in October 2015. The software was created to maintain the anonymous nature of the sender and receiver of data and maintain the integrity of the data travelling from a point to another through networks.\r\n<blockquote>\u201cIn its simplest terms, it\u2019s a little piece of software that first confirms that it knows the computer it is talking to, and that\u2019s how in some ways, you don\u2019t have to worry about whether you\u2019re on the other line or not, it knows that your computer is the computer that my computer trusts, but then it layers on top of that this ability to authenticate data before it\u2019s broken into packets as the packets go out across the network.\u201d</blockquote>\r\nOther previous projects of note include:\r\n<ul>\r\n\t<li>SimpleHelp app: a micro-philanthropy application conducted by undergraduate students which provides opportunities to prospective donors and volunteers to connect with local agencies that are in need of money or help.</li>\r\n\t<li>The Virtual Town Project, a civic participation application to allow citizen input and media oversight of local government meetings and operations which was discontinued in September 2012.</li>\r\n</ul>\r\nIn terms of the approach used to foster and develop media innovation, Williams does not feel constrained by any requirements and does not follow any specific metrics besides those regarding the maintenance of the academic quality level that needs to be met and delivered for the media innovation class.\r\n<blockquote>\u201cFrom the lab\u2019s perspective, I never really was given any specifics except for what might have been attached to funding that I gained for the lab. In other words, the university kind of gave me pretty much free reign, and that was a splendid place to be. Some of the funders, of course, they have their metrics for what happens.\u201d</blockquote>\r\nNevertheless, Williams suggests that the Knight Foundation was very much about learning, and this encompasses both successful and unsuccessful projects. It\u2019s the learning from the process that was key for them. And he maintains the same open policy, without any demands or restrictions when it comes to the products launched by the lab:\r\n<blockquote>\u201cI don\u2019t limit the students to create the next greatest app any more than limit them to simply doing a research project that compares multiple new things that are out there, I allow a little bit of both those things and that\u2019s important, partly for my students, but also for my faculty who collaborate with us,\u201d he added.</blockquote>\r\n<h3>Future plans</h3>\r\n<blockquote>\u201cThe world here has changed in the sense that post-election and as we\u2019ve survived the first 123 days of Donald Trump, awareness of media and its value to our society, at least certainly in this country, has really spiked upward, people are suddenly realising again that the news media is the really critical part of our society, so in that form, you know, it\u2019s opening up some other doors in some other research areas\u201d says Williams.</blockquote>\r\nFor the future, he expects the interest in media and its innovation to continue to rise and is determined to maintain the same work approach and continue to develop other projects, while also upgrading the media innovation lab\u2019s facilities..\r\n\r\nAcknowledging the Trump administration\u2019s fundamental shift of American politics, he does suggest that \u201cfrom the stand point of perhaps breathing life back into the American media, it\u2019s been a godsend, because it really has raised awareness of the value of media in our society.\u201d\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-10683 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/michael-williams2-e1496481075593.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nMichael Williams, Director, KU Media Innovation Lab\r\n\r\nLab website: https://milab.drupal.ku.edu/\r\nLinkedIn: <a href=\"https://www.linkedin.com/in/profwilliams/\" target=\"_blank\" rel=\"noopener noreferrer\">https://www.linkedin.com/in/profwilliams/</a>\r\nTwitter: <a href=\"https://twitter.com/mikewms\" target=\"_blank\" rel=\"noopener noreferrer\">@mikewms</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"University of Kansas Media Innovation Lab: bringing students, professors and industries together for media innovation","post_link":"https://media-innovation.news/media-lab/university-kansas-media-innovation-lab-bringing-students-professors-industries-together-media-innovation/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Kansas Media Innovation Lab: bringing students, professors and industries together for media innovation\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/kansas-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic Lab, academic research, prototypes, software, training and education, USA","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527003144:101","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_focuskw_text_input%":"Media Innovation Lab","%_yoast_wpseo_focuskw%":"Media Innovation Lab","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"10748","%_wpgmp_location_address%":"William Allen White Elementary School, Exchange Street, Emporia, KS, United States","%_wpgmp_metabox_latitude%":"38.4091868","%_wpgmp_metabox_longitude%":"-96.17462069999999","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545608346,"payload":[{"id":11362},{"id":10942},{"id":10673}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic Lab, academic research, prototypes, software, training and education, USA"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10681,"infowindow_disable":false},{"source":"post","title":"AFP Medialab: information verification and user experience at the core of newsroom innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"AFP Medialab: information verification and user experience at the core of newsroom innovation\" width=\"300\" height=\"178\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/Earthnews-300x178.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">AFP Medialab: information verification and user experience at the core of newsroom innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            A small team of journalists and engineers are developing new tools for the newsroom and building innovative user experiences to valorise AFP's content.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/afp-medialab/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"A small team of journalists and engineers are developing new tools for the newsroom and building innovative user experiences to valorise AFP's content.","address":"11 Place de la Bourse, 75002 Paris","location":{"lat":"48.85661400000001","lng":"2.3522219000000177","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/afp-medialab/","zoom":2,"extra_fields":{"post_excerpt":"A small team of journalists and engineers are developing new tools for the newsroom and building innovative user experiences to valorise AFP's content.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>AFP Medialab: information verification and user experience at the core of newsroom innovation</h1>\r\n<strong>AFP Medialab is a small team of journalists and engineers developing new tools for the newsroom, like content verification or speech-to-text, and building innovative user experiences to valorise AFP's content through interactive video or automated geolocalised news displays.</strong>\r\n\r\nAgence France Presse (AFP) is a global news agency delivering fast, in-depth coverage of the events shaping our world from wars and conflicts to politics, sports, entertainment and the latest breakthroughs in health, science and technology. Founded in 1944 and headquartered in Paris, it is one of the top three news agency in the world. Its 1575 journalists (out of 2326 employees) produce each day some 5000 dispatches, 3000 pictures, 200 videos and 100 graphics and videographics.\r\n\r\nAFP Medialab R&amp;D is what remains from a former Multimedia development division created at the end of 1990\u2019s . At the time, the priority was to develop multimedia and Internet production within the company. Nowadays, although priorities and general direction are fixed by an innovation committee at company level, the lab focuses on creating new user experiences around AFP\u2019s content, in trying to solve \u201creal life\u201d problems for journalists developing news tools.\r\n<blockquote>\u201cIn information verification, our approach is based on design thinking methodology to keep the innovation user-centred. We observe how users are working and we try to understand where we can help them being more efficient, solve bottlenecks and decrease time-consuming tasks,\u201d says Denis Teyssou, Editorial Manager at the AFP Medialab.</blockquote>\r\n<h3>Solutions for the newsroom</h3>\r\n\u201cOne of the most interesting things that has happened in information and communication in the last 15 years is the rise of user generated content (photos, videos etc.),\" says Teyssou. \"This also comes with the difficulty of verifying this content created by the audience.\u201d\r\n\r\nIn an attempt to solve this challenge, they are currently involved in a Horizon 2020 European-funded project named <a href=\"http://www.invid-project.eu/\" target=\"_blank\" rel=\"noopener noreferrer\">InVID</a> which focuses on digital files as well as contextual and user rights verifications of user generated video on social networks. Other participants include the Austrian Press Agency technical subsidiary APA-IT and German broadcaster Deutsche Welle.\r\n\r\nAFP Medialab has already completed eight successful research and innovation projects and have developed some groundbreaking prototypes like EarthNews (a news mashup on a NASA open source framework) or AFP4W (a platform to query events and build on-the-fly timelines, mashups, ebooks) in a previous European project. After having completed a research project and once the technology is mature, they will often try to put it into practice in order to create useful solutions for the newsroom. The idea, according to Denis Teyssou, is to go from invention to innovation instead of remaining in the invention phase.\r\n\r\nThis type of thinking led for example to the AFP <a href=\"https://www.afp.com/en/agency/medialab/afp-transcriber\" target=\"_blank\" rel=\"noopener noreferrer\">Transcriber software</a>, which is a collaboration with a spin-off of the research institute CNRS: <a href=\"http://www.vocapia.com/\" target=\"_blank\" rel=\"noopener noreferrer\">Vocapia</a>. AFP journalists can now use it to transcribe their videos, interviews, pressers, by using this application which extract an mp3 file send it to Vocapia and retrieves back the text transcription which is regularly enhanced through the detection of neologism and new named entities (proper names) in news feeds. And it works in some 20 languages, while the main limitation is the quality of the audio recording.\r\n<blockquote>\u201cTranscribing interviews is seen as one of the most tedious tasks by journalists. If you come back from an interview of 1 hour, you can now get back the transcription in 4 or 5 minutes. Also, the transcription is completely synchronised with the video, so you can click on a word and the video or audio will start to play there,\u201d explains Denis Teyssou.</blockquote>\r\nThe application is currently used by AFP's video and political departments and will probably be used as a form of video archiving for the newsroom at a later stage.\r\n<h3><img class=\"aligncenter wp-image-10711 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/AFPTranscriber.png\" alt=\"\" width=\"938\" height=\"869\" /></h3>\r\n<h3></h3>\r\n<h3>User-driven innovation and design thinking methodology</h3>\r\nKeeping the user always in mind, the lab\u2019s activities are focused on experimenting with new technologies and trying to find out innovative ideas in products, processes and services. However, it is not always easy to receive user-feedback, because it's an iterative process that demands time and the users are mostly journalists who are always working. Although it's easier to find users within a large newsroom like the one at AFP. Especially since the Medialab is located in the newsroom, in between the video and infographics departments.\r\n<blockquote>\u201cWe managed to organise when needed specific sessions with dozens of AFP journalists, for testing and demos during a couple of hours. Although they have little time, their responses are good. Sometimes more tech-savvy people are learning more quickly, while other need more time to figure it out. But when it really solves something, when they see the benefit, then people are really keen to use it, as is the case for the AFP Transcriber.\u201d</blockquote>\r\nStaffed by two journalists and two engineers, the Medialab has also integrated user feedback into its interdisciplinary team.\r\n<h3>Innovating within AFP</h3>\r\nAlthough reporting regularly on their achievements to the innovation internal committee, the Medialab is an independent-minded entity within AFP and this fits perfectly with the spirit of a research and development lab. Their work is also largely supported by public funding either on a European level (the Horizon 2020 framework), as is the case with InVID, or on a National level (National Research Agency or the Ministry of Economy). This is the case with the ASRAEL project, which is about extracting data on media events from AFP wires and the web.\r\n\r\nOne of the main advantage of being part of an international news agency like AFP is the massive and multilingual production of content. This mine of texts, videos, infographics and images is accessible to the lab and can be used to build something quite quickly. The fact that AFP has links with the French state and the central position of AFP in France and in the world makes cooperation with universities and laboratories easier as well: \u201cAFP content is attractive for the research community. If you're setting up a project and you can have access to our content, that gives you a lot of material to work with.\u201d\r\n\r\nWith new forms of narratives and storytelling appearing just around the corner (interactive, immersive, 360\u00b0 video, virtual and augmented reality etc.) they are convinced that research should be centred on user-experience even more so than before. \u201cWe know that the industry is facing problems and we know that there are some external opportunities like collaborating with startups or joining funded research programmes, that can help us to find solutions to tackle these challenges.\u201d\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-10707 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/DT-GoogleGlass.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nDenis Teyssou, Editorial Manager, AFP Medialab\r\nWeb:\u00a0<a href=\"https://www.afp.com/en/agency/MediaLab\" target=\"_blank\" rel=\"noopener noreferrer\">https://www.afp.com/en/agency/MediaLab/</a>\r\nTwitter: <a href=\"https://twitter.com/dteyssou\" target=\"_blank\" rel=\"noopener noreferrer\">@dteyssou</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"AFP Medialab: information verification and user experience at the core of newsroom innovation","post_link":"https://media-innovation.news/media-lab/afp-medialab/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"AFP Medialab: information verification and user experience at the core of newsroom innovation\" width=\"300\" height=\"178\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/Earthnews-300x178.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic research, design thinking, France, horizon 2020, news agency, prototypes, UX","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527003198:101","%_edit_last%":"101","%_thumbnail_id%":"10705","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"69","%_kleo_title_checkbox%":"1","%_yoast_wpseo_focuskw_text_input%":"newsroom","%_yoast_wpseo_focuskw%":"newsroom","%_yoast_wpseo_metadesc%":"A small team of journalists and engineers are developing new tools for the newsroom and building innovative user experiences to valorise AFP's content.","%_yoast_wpseo_linkdex%":"79","%_wpgmp_location_address%":"11 Place de la Bourse, 75002 Paris","%_wpgmp_metabox_latitude%":"48.85661400000001","%_wpgmp_metabox_longitude%":"2.3522219000000177","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545330675,"payload":[{"id":10651},{"id":11154},{"id":11714}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic research, design thinking, France, horizon 2020, news agency, prototypes, UX"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10704,"infowindow_disable":false},{"source":"post","title":"NewsThings: exploring what the Internet of Things could be for news and information","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NewsThings: exploring what the Internet of Things could be for news and information\" width=\"300\" height=\"201\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/newsthings2-300x201.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">NewsThings: exploring what the Internet of Things could be for news and information</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            This collaborative project aims to understand how journalism could harness connected things to find new ways of connecting with people and conveying stories, and to create prototypes that will allow this in the near future. \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/newsthings-exploring-what-the-internet-of-things-could-be-for-news-and-information/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"This collaborative project aims to understand how journalism could harness connected things to find new ways of connecting with people and conveying stories, and to create prototypes that will allow this in the near future. ","address":"University of Central Lancashire, Preston, United Kingdom","location":{"lat":"53.7655397","lng":"-2.709529800000041","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/newsthings-exploring-what-the-internet-of-things-could-be-for-news-and-information/","zoom":2,"extra_fields":{"post_excerpt":"This collaborative project aims to understand how journalism could harness connected things to find new ways of connecting with people and conveying stories, and to create prototypes that will allow this in the near future. ","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1><strong>NewsThings: exploring what the Internet of Things could be for news and information </strong></h1>\r\n<strong>With some analysts predicting the Internet of Things as the next digital revolution, and the recent releases of mass market devices such as Google Home and Amazon Echo, the question for news media is how they could capitalise on an emerging world of connected objects, smart assistants and live sensor networks.</strong>\r\n\r\nNewsThings - a collaboration between the University of Central Lancashire\u2019s Media Innovation Studio, Trinity Mirror and creative agency Thomas Buchanan \u2013 seeks to do just that. Using co-design and user-centred design approaches, the project seeks to prototype physical devices that connect to the web and convey news and information in new ways.\r\n\r\nJohn Mills, lecturer and researcher at the Media Innovation Studio, explains that these products could convey rich media experiences or \u201cdeconstruct news and provide new ways of conveying either breaking news, richer media or information from within a community\u201d.\r\n\r\nAlison Gow, digital innovations editor at Trinity Mirror Regionals, adds:\r\n<blockquote><em>\u201c</em>The idea of linking digital and physical spaces, and investigating the intersection of news media and consumers/customers, is fascinating but - despite the growth of IoT availability, from Nest to Raspberry pi - not an area legacy media are dedicating time to investigating, so the opportunity to explore this area, with NewsThings, was incredibly exciting.\u201d</blockquote>\r\n<h3><strong>Deep insights fuel innovation </strong></h3>\r\nThe \u20ac50k project, which is supported by Google\u2019s Digital News Initiative, runs from March to December 2017, and will place users and industry at the very core of the innovation process. Through running workshops with audience members and representative from Trinity Mirror\u2019s editorial, commercial, marketing and data units, and combining this approach with a range of creative design methods, the team will create three-five prototypes that are directly relevant to both user requirements and industry concerns.\r\n\r\n<img class=\"aligncenter wp-image-10698 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/newsthings3.jpg\" alt=\"\" width=\"800\" height=\"533\" />\r\n\r\n&nbsp;\r\n\r\nThe methods that will be used as part of this process aim to reveal insights that analytic data may not provide. Using workshops that map an audience-member\u2019s engagement with news and information from multiple sources and engaging how they feel about news, rather than merely consumption habits from one publisher, the team hope to uncover insights that could feed directly into IoT product development, and enhance standard data collection and analytics.\r\n\r\nThomas Buchanan is leading on the development and deployment of cultural probes, which are effectively a kit of tasks that readers take on each day. They range from buying a favourite or least favourite paper and talking to friends and family about the content, and reflecting on the result, taking pictures of their surroundings, mapping the news-prompted emotions using emojis and creating their own paper. The tasks are playful, challenging and also underpinned via a number of academic disciplines. These span design, human-computer interaction and behavioural science.\r\n\r\nJohn Mills, researcher at the Media Innovation Studio, explains: \u201cThis is an amazing opportunity to explore new, perhaps more compelling, ways of interacting and engaging with news and information through objects and our environment.\u201d\r\n<h3><strong>Opportunities through collaboration </strong></h3>\r\nThrough collaborating or involving a number of stakeholders in both the product design and core partnership more generally, it\u2019s hoped that the physical products and digital services around them will be more relevant to the target audience and industry partner.\r\n<blockquote>\u201cWe have a brilliant partnership... Individually we have all been working on innovation projects within journalism and IoT for years, and our expertise across design, technology, journalism and research, makes this project such an exciting one,\u201d Tom Metcalfe, creative director and founder of Thomas Buchanan, suggests.</blockquote>\r\nAlison Gow adds that \u201cit\u2019s really exciting to be involved in something that ties so closely to our values of breaking news, and local information and audience engagement. It\u2019s a unique opportunity to really understand how content delivery and interaction between the worlds of\u00a0media and tech and the audience can and will quickly evolve.\u201d\r\n<h3><strong>Building on solid foundations </strong></h3>\r\nThe team members have all explored the Internet of Things in unique ways previously, and this project could be seen as a logical extension of this work.\r\n\r\nFor example, the Liverpool Echo, published by Trinity Mirror, created a IoT version a Liver bird \u2013 the symbol of Liverpool \u2013 that displayed real time editorial analytic information to the newsroom. Thomas Buchanan specialises in connected objects, and the collaborative and single use Raincloud device streams weather information to an object that displays the information simply.\r\n\r\nThe Media Innovation Studio has operated in the IoT space for a number of years and has explored situated voting devices for local communities, conductive inks and interactive print, \u2018data pets\u2019 that monitor pollution in a local area and connected drones for use in media, humanitarian aid and search and rescue scenarios. It has also connected its office\u2019s coffee machine to its website to share the caffeine consumption to the world.\r\n\r\nLooking to the future of NewsThings, Mills feels that IoT could be of great interest to the news media:\r\n<blockquote>\u201cWhether it\u2019s physical objects that convey news, such as the growing range of smart home assistants, locative broadcasting via beacons or creating new stories from connected sensor networks data-drive journalism, the Internet of Things and our growing immersion in digital technologies will create both challenges and opportunities for the sector for at least the next five years and well beyond,\u201d Mills suggests.</blockquote>\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-10701 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/john-mills-e1496482562849.png\" alt=\"\" width=\"164\" height=\"210\" />\r\n\r\nJohn Mills, Lecturer and Researcher, Media Innovation Studio\r\nWeb: <a href=\"http://mediainnovationstudio.org/\" target=\"_blank\" rel=\"noopener noreferrer\">http://mediainnovationstudio.org/</a>\r\nTwitter: <a href=\"https://twitter.com/_johnmills\" target=\"_blank\" rel=\"noopener noreferrer\">@_johnmills</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_column_text]\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>[/vc_column_text][/vc_column][/vc_row]","post_title":"NewsThings: exploring what the Internet of Things could be for news and information","post_link":"https://media-innovation.news/media-lab/newsthings-exploring-what-the-internet-of-things-could-be-for-news-and-information/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NewsThings: exploring what the Internet of Things could be for news and information\" width=\"300\" height=\"201\" src=\"https://media-innovation.news/wp-content/uploads/2017/06/newsthings2-300x201.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"internet of things, multidisciplinary, prototypes, UK","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1531137428:82","%_edit_last%":"101","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_checkbox%":"1","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_focuskw_text_input%":"NewsThings","%_yoast_wpseo_focuskw%":"NewsThings","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"142","%_thumbnail_id%":"10697","%_wpgmp_location_address%":"University of Central Lancashire, Preston, United Kingdom","%_wpgmp_metabox_latitude%":"53.7655397","%_wpgmp_metabox_longitude%":"-2.709529800000041","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545475710,"payload":[{"id":10776},{"id":11833},{"id":11032}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"internet of things, multidisciplinary, prototypes, UK"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10693,"infowindow_disable":false},{"source":"post","title":"INJECT: a journalism and technology project building creativity tools for journalists","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"INJECT: a journalism and technology project building creativity tools for journalists\" width=\"300\" height=\"137\" src=\"https://media-innovation.news/wp-content/uploads/2017/05/IMG_9129-300x137.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">INJECT: a journalism and technology project building creativity tools for journalists</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The INJECT project unites 14 partners in 6 European countries in the development of new digital technologies for news organisations.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/inject-a-european-journalism-and-technology-project-building-creativity-tools-for-journalists/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The INJECT project unites 14 partners in 6 European countries in the development of new digital technologies for news organisations.","address":"University of London, Malet Street, London, United Kingdom","location":{"lat":"51.5229378","lng":"-0.13082059999999274","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/inject-a-european-journalism-and-technology-project-building-creativity-tools-for-journalists/","zoom":2,"extra_fields":{"post_excerpt":"The INJECT project unites 14 partners in 6 European countries in the development of new digital technologies for news organisations.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>INJECT: a journalism and technology project building creativity tools for journalists</h1>\r\n<strong>The INJECT project unites 14 partners in 6 European countries in the development of new digital technologies for news organisations. The goal is to improve the creativity and productivity of journalists in a digital world, so they can continue to perform their crucial role in open societies.</strong>\r\n\r\nINJECT, Innovative Journalism: Enhanced Creativity Tools, is a European project uniting 14 partners in 6 countries, including the Global Alliance for Media Innovation. This project has received funding from the European Union\u2019s Horizon 2020 research and innovation programme. INJECT\u2019s objective is to transfer new digital technologies to news organisations to improve the creativity and productivity of journalists, in order to increase the competitiveness of European news and media organisations.\r\n\r\nThe INJECT project\u00a0builds on results from the 2016 Google-funded JUICE project at City, University of London, as a collaboration between the Centre for Creativity in Professional Practice at the Cass Business School and the Journalism Department. Broader research into new tools for journalists won an EU Horizon 2020 grant of just under \u20ac1m, and the INJECT project started its work in January 2017.\r\n\r\nProfessor of Digital Creativity at City, University of London Neil Maiden is leading this industry-academic collaboration and believes INJECT \u201cis the first tool that seeks to integrate productivity and creativity support directly into the digital work of journalists. It builds on successes in other domains to deliver key innovations in journalism.\u201d\r\n<h3>Creativity support tools</h3>\r\nThe idea is not to make journalists more creative, as it is acknowledged that journalism is a creative profession. However, journalists need enough time and resources in order to be creative. As journalists are under increased pressure to produce stories for a 24/7 news cycle and discussions about churnalism, filter bubbles and fake news raise questions about the possibility to do so, finding ways to continue producing original and quality stories is more urgent than ever. Neil Maiden explains:\r\n<blockquote>\u201cWhat INJECT will do is to make journalists as creative as they are at the moment, but more efficiently. The INJECT tool will do this by implementing strategies that will enable them to undertake some of the work of experienced journalists more quickly, to permit and support journalists to spend more time on creative thinking and story development.\u201d</blockquote>\r\nThe tool includes a creative search engine that reporters can use to search relevant information sources for new angles, and to investigate further and deeper into the background of the stories they are working on, as well as a functionality that brings articles to life with interactive fact cards.\r\n\r\nThe tool is also designed to integrate seamlessly with the tools that journalists already use, as simple sidebars and add-ons to Google Docs, WordPress and targeted content management systems. Journalists do not need to change how they work, to use INJECT.\r\n<h3><img class=\"aligncenter wp-image-10649 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/05/inject_demo_general.gif\" alt=\"\" width=\"600\" height=\"338\" /></h3>\r\n<h3></h3>\r\n<h3>Innovating together</h3>\r\nINJECT is a collaborative innovation project joining journalists, academics, research centres, developers, media organisations and business organisations. By integrating journalists' feedback directly into the developing process, INJECT aims to build creativity tools that are helpful and easy to use in the newsroom.\r\n\r\nTo this end, consortium members of the University of Bergen, M'Labs, Explaain and City, University of London visited the local newspapers Sunnhordland and Hordaland in Norway this spring to discuss possibilities for the local implementation of the INJECT tool. The editor in chief at Sunnhordland, Magne Kydland, showed\u00a0the team how the newspaper is run. The consortium participated in the daily editorial meeting, talked to editorial and technical staff, and presented INJECT in a plenary session.\r\n\r\nInitially, the tool will be further developed in collaboration with the local Norwegian newspapers. Later, a similar endeavour will be launched in collaboration with the Dutch journalism partners in the consortium, freelancer networks VersPers and VJ Movement. The idea is to develop different versions of the tool for different journalism markets across Europe.\r\n<h3>INJECT: Technology meets journalism</h3>\r\nExploring the ways in which technology can support journalists' work, INJECT uses creativity techniques based on Natural Language Processing (NLP). Specifically, it is adapting digital search to mimic how experienced journalists work creatively, to discover new angles on stories. More specialised search can support journalists to discover new information and story angles, to do this more quickly than at present, and to generate the resulting stories more productively.\r\n<blockquote>\u201cThere are clearly some outcomes of computer science research that exceed current human abilities. One of these is search. Digitalisation enables the effective search of large volumes of information much more quickly and accurately than people can. Search is important in journalism, to discover data, the back story, human angles and the underpinning causes - the long read.\u201d</blockquote>\r\nINJECT also scans texts for keywords and automatically links them to additional information. In order to make it easy for journalists to integrate the toolkit into their work practices, the software will be built directly into content management systems.\r\n\r\nAccording to Professor of Journalism George Brock (City, University of London) \"INJECT aims to do something which no other software for journalism attempts: to combine creative search techniques and ways of telling the reader more about background and sources. And this help is easy to use and fast.\"\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-10648 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/05/neil-1.jpeg\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nNeil Maiden, Project Coordinator INJECT, City, University of London\r\nWeb: <a href=\"http://injectproject.eu/\" target=\"_blank\" rel=\"noopener noreferrer\">http://injectproject.eu/</a>\r\nTwitter: <a href=\"https://twitter.com/NeilMaiden\" target=\"_blank\" rel=\"noopener noreferrer\">@NeilMaiden</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"INJECT: a journalism and technology project building creativity tools for journalists","post_link":"https://media-innovation.news/media-lab/inject-a-european-journalism-and-technology-project-building-creativity-tools-for-journalists/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"INJECT: a journalism and technology project building creativity tools for journalists\" width=\"300\" height=\"137\" src=\"https://media-innovation.news/wp-content/uploads/2017/05/IMG_9129-300x137.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"digital creativity, Europe, horizon 2020, multidisciplinary, partnerships, tools, UX","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527003465:101","%_edit_last%":"101","%slide_template%":"default","%_yoast_wpseo_primary_category%":"69","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_yoast_wpseo_content_score%":"30","%_kleo_title_checkbox%":"1","%_yoast_wpseo_metadesc%":"The INJECT project unites 14 partners in 6 European countries in the development of new digital technologies for news organisations.","%_thumbnail_id%":"10646","%_yoast_wpseo_focuskw_text_input%":"project","%_yoast_wpseo_focuskw%":"project","%_yoast_wpseo_linkdex%":"79","%_wpgmp_location_address%":"University of London, Malet Street, London, United Kingdom","%_wpgmp_metabox_latitude%":"51.5229378","%_wpgmp_metabox_longitude%":"-0.13082059999999274","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545606283,"payload":[{"id":10673},{"id":11024},{"id":11195}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"digital creativity, Europe, horizon 2020, multidisciplinary, partnerships, tools, UX"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10645,"infowindow_disable":false},{"source":"post","title":"Nordjyske Startup: incubator within the second oldest media company in Denmark","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Nordjyske Startup: incubator within the second oldest media company in Denmark\" width=\"300\" height=\"165\" src=\"https://media-innovation.news/wp-content/uploads/2017/05/HeaderPhoto-300x165.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Nordjyske Startup: incubator within the second oldest media company in Denmark</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            In return for new ideas and knowledge, media house Nordjyske Medier offers startups its expertise and network to develop their businesses further.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/nordjyske-startup-incubator/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"In return for new ideas and knowledge, media house Nordjyske Medier offers startups its expertise and network to develop their businesses further.","address":"NORDJYSKE Media A / S, Langagervej, Aalborg \u00d8st, Denmark","location":{"lat":"57.0201625","lng":"9.975647200000026","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/nordjyske-startup-incubator/","zoom":2,"extra_fields":{"post_excerpt":"In return for new ideas and knowledge, media house Nordjyske Medier offers startups its expertise and network to develop their businesses further.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Nordjyske Startup: incubator within the second oldest media company in Denmark</h1>\r\n<strong>Since the start of the innovation lab in January this year, two startups have moved into the Nordjyske Medier building in Aalborg. In return for new ideas and knowledge, this Danish media house offers them its expertise and network to develop their businesses further.</strong>\r\n\r\nNordjyske Medier is one of the biggest regional media houses in Northern Denmark. In its 250 years of history it has been at the forefront of innovation, with the creation of the first 24-hour television channel in Denmark and it's objective to \u201censure freedom and independence through a profitable operation based on innovation and dynamics.\u201d\r\n\r\nInnovation is key in the media industry today, as it is in many others. But a lack of resources within media organisations can limit their possibilities to invest in research and development. Nordjyske Startup invites students and startups to come and work with them on topics that Nordjyske Medier is interested in, ranging from AI, big data and virtual reality to location-based services, community reporting and business models.\r\n<blockquote>\u201cIt's quite hard to be in the media business,\u201d Innovation Manager Katja Bundgaard explains the reason for starting the incubator. \u201cWe are struggling to make money on news. So we know we're forced to make new products. And because every employee in this company is working a 100% already, we need to get inspiration from outside. And we think that if we can get some startups who know something about stuff that might be a new product, that would be a good way, and a cheap way, to get cleverer.\u201d</blockquote>\r\nTogether with Innovation Manager Mette Kjul Pedersen, she is responsible for Nordjyske Startup.\r\n<h3>Knowledge exchange</h3>\r\nIn return for new ideas and a different mentality, the startups benefit from the media company's extensive network, office space and expertise to facilitate the development of their ideas. Furthermore, Mette and Katja would like to create a collaboration with students, who could research these fields of interest more deeply and bring new knowledge to the company: \u201cWe think of it as a knowledge exchange. So they know something that we maybe don't know or don't have the time to research and we learn from them. And they learn from our competences as well as an old media house.\u201d\r\n\r\nSpecifically, the startups can walk into Nordjyske Medier's marketing, sales or human relations offices whenever they have a question and their advisory board challenges them to think about basic elements of running a business that they had not considered before. \u201cWhat is most valuable for the startups is definitely the advisory boards,\u201d says Katja Bundgaard. \u201cAnd we're also offering a personal mentor for personal development. Not about the project or about the idea, but for the personal development.\u201d\r\n<h3>New ideas for the media industry</h3>\r\nFrom the ten applications they received since January, two startups have been selected. One is working on a platform for recommendations about where to live while the other one is matching students with jobs. Although their ideas are not completely related to the fields of interest defined, Mette Kjul Pedersen believes that their specific approach and mentality bring a lot of value to Nordjyske Medier: \u201cWe thought that learning from the mindset they have when they go into platform innovation could be healthy for us. And we also want to get the effect on our company culture from the young startups.\u201d\r\n\r\nMette and Katja hope to bring in more startups that are really working on their areas of interest, but it is a challenge to find media tech companies in Aalborg. While there are many financial tech, green tech and technology startups in the city, the local university does not have a journalism program and so students are not really in their business. \u201cI think that if we would have been situated in Copenhagen it would have been easier,\u201d Katja Bundgaard admits.\r\n\r\nAs a solution, they are looking to collaborate with the university of Aarhus. They have been bringing in journalism students from Aarhus, which is 1.5 hours away: \u201cWe have paid for their hotels while they were doing their project here, so we can do that. We can pay them for hotels and trains and whatever they need. If they have the right idea, we're willing to do that.\u201d\r\n<h3>A fun work environment</h3>\r\nBesides collaboration with universities and bringing in students and startups, Katja and Mette also want to work on the office environment, making it more creative and less boring. Their role as innovation managers is to inspire the startups. They not only do that through writing about innovation and organising relevant workshops and events, and inviting speakers:\r\n<blockquote>\u201cWe hope to make a really positive learning environment for the startups. Because they say that's actually also very valuable. To talk to other people in the same situation. So we want to make a more creative office space. We want to have four startups actually, that's our personal goal this year. And we want to make them cooperate between the startups, so they can use each other.\u201d</blockquote>\r\nThey are convinced that they have a lot to offer media-oriented startups in the development of their ideas and have received very positive feedback from the startups so far: \u201cThey love it!\u201d according to Mette Kjul Pedersen, \u201cThey think that it's so nice to have access to different competences and do not to have to think about the practical stuff and only think about their business.\u201d\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-10615 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2017/05/MettePhoto-1.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nMette Kjul Pedersen, Innovation Manager, Nordjyske Startup\r\nWeb:\u00a0<a href=\"http://www.nordjyskestartup.dk/\" target=\"_blank\" rel=\"noopener noreferrer\">www.nordjyskestartup.dk</a>\r\nTwitter: <a href=\"https://twitter.com/MKjul\" target=\"_blank\" rel=\"noopener noreferrer\">@Mkjul</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h3>Author</h3>\r\n[simple-author-box][/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Nordjyske Startup: incubator within the second oldest media company in Denmark","post_link":"https://media-innovation.news/media-lab/nordjyske-startup-incubator/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Nordjyske Startup: incubator within the second oldest media company in Denmark\" width=\"300\" height=\"165\" src=\"https://media-innovation.news/wp-content/uploads/2017/05/HeaderPhoto-300x165.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"business coaching, Denmark, incubator, media house, startups, students","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1527003513:101","%_edit_last%":"101","%slide_template%":"default","%_yoast_wpseo_primary_category%":"69","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_metadesc%":"In return for new ideas and knowledge, media house Nordjyske Medier offers startups its expertise and network to develop their businesses further.","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_kleo_site_style%":"wide","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"10622","%_yoast_wpseo_focuskw_text_input%":"media","%_yoast_wpseo_focuskw%":"media","%_yoast_wpseo_linkdex%":"79","%_wpgmp_location_address%":"NORDJYSKE Media A / S, Langagervej, Aalborg \u00d8st, Denmark","%_wpgmp_metabox_latitude%":"57.0201625","%_wpgmp_metabox_longitude%":"9.975647200000026","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545098608,"payload":[{"id":10101},{"id":10201},{"id":10991}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"business coaching, Denmark, incubator, media house, startups, students"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10613,"infowindow_disable":false},{"source":"post","title":"Time Inc UK Innovation Lab: accelerated product development","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Time Inc UK Innovation Lab: accelerated product development\" width=\"300\" height=\"167\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/lab_1-300x167.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Time Inc UK Innovation Lab: accelerated product development</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Insights, intelligence, incubation and propagation - How Time Inc. UK adopted rapid development to drive new products.\r\n\r\n\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/time-inc-uk-innovation-lab-accelerated-product-development/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Insights, intelligence, incubation and propagation - How Time Inc. UK adopted rapid development to drive new products.\r\n\r\n","address":"Time Inc UK Ltd, Farnborough, United Kingdom","location":{"lat":"51.284782","lng":"-0.7625679999999875","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/time-inc-uk-innovation-lab-accelerated-product-development/","zoom":2,"extra_fields":{"post_excerpt":"Insights, intelligence, incubation and propagation - How Time Inc. UK adopted rapid development to drive new products.\r\n\r\n","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Time Inc UK Innovation Lab: accelerated product development</h1>\r\n<strong>Time Inc. UK\u2019s Innovation Lab seeks to tap into user and audience insights to move product development into new print or digital spaces and explore evolving audience requirements. With a core team of three people, but with the ability to pull in additional skills and resource based on need, it does this at speed - employing an agile method to build, test and integrate market-tested products into the organisation.</strong>\r\n\r\n&nbsp;\r\n\r\n<em><strong>-- The Time Inc Lab closed down since we talked to them in 2016 --</strong></em>\r\n\r\n&nbsp;\r\n\r\nEstablished 18 months ago, the Lab was given a mandate to create new digital products that complement some of the company\u2019s magazine brands - such as NME. The Lab\u2019s prototyping and build process has built on existing rapid build models - such as Lean development - and has resulted in a range of new products that offer unique market entrants, or present existing brands with new digital opportunities.\r\n\r\nRichard Giddings, head of new product development at the Innovation Lab, explains: \u201cThe motivation behind starting the Lab was to develop a process that would allow us to rapidly bring to market new organic launches.\u201d\r\n\r\nTo help drive rapid and disruptive innovation, the Lab was set up outside existing editorial and technical structures. It\u2019s remit was to develop a startup methodology and independently-generated products, but to still visibly operate within Time Inc. UK and have a concrete process for connecting to it when delivering products.\r\n\r\n&nbsp;\r\n<h3>Innovation methods</h3>\r\n<img class=\"wp-image-10156 size-full aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/lab_1.png\" alt=\"\" width=\"1440\" height=\"802\" />\r\n\r\n<img class=\"wp-image-10157 size-full aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/lab_2.png\" alt=\"\" width=\"1440\" height=\"809\" />\r\n\r\nThe Lab has evolved a specific development process that Giddings suggests stand apart from traditional product development and evolves existing approaches to incubation or rapid prototyping. Borrowing from <a href=\"http://theleanstartup.com/principles\">Eric Ries\u2019 Lean method</a>, which supports rapid development via its \u2018learn, build and measure\u2019 iterative cycle, and<a href=\"https://developers.google.com/design-sprint/\"> Google Design Sprints</a>\u2019 short process of \u2018understand, define, diverge, design, prototype and validate\u2019, which places insights and measurable learning at the centre of the\r\n\r\n\u201cWe\u2019re not a start-up incubator - this is an important point of difference, we\u2019re very much an accelerated delivery team. The Lean process is excellent for us to deliver products, deliver technical change and deliver a platform, but the design sprint process gets us to the prototype and the nub of consumer need very quickly.\u201d\r\n\r\nSpeed and concrete data underpin Time Inc. UK\u2019s Innovation Lab\u2019s approach. It\u2019s phases are\r\n<p style=\"text-align: center;\"><strong>Insight &gt; Build &gt; Measure &gt; Learn &gt; Incubate &gt; Propagate</strong></p>\r\nInsights - This is the starting point. Audience data and market insights are essential to the process of generating what users need. Workshops and focus groups add to the datasets, and begin generate product concepts. The result is a product concept hypothesis\r\n\r\nBuild - Following the generation of insights and creation of a hypothesis, the next stage of the process is to create a minimum viable product. These two elements can take anywhere between two days and two weeks, but no longer.\r\n<blockquote>\u201cThe build process could be as simple as a social marketing campaign, an email campaign, or building a throwaway website landing page. Basically, whatever it takes to prove a hypothesis based on intelligence. Everything we do, we measure. So whilst we\u2019re testing, we have very clear KPIs defined about what positive and negative tests look like,\u201d Giddings continues.</blockquote>\r\nMeasure - Following the build, the process moves into a phase based around learning and validating the concept against these KPIs.\r\n\r\nLearn - Moving into a reflective phase, this is where the Lab analyse the product performance against the initially identified potential. \u201cIf something\u2019s failing, kill it and move on, if it\u2019s working evolve that product,\u201d Giddings explains. If it\u2019s successful, the product continues to remain within the Lab in an incubation stage.\r\n\r\nIncubate - \u201cIf we\u2019ve proven a hypothesis during the insight, build, measure and learn phase, we will pull together a business plan based on short and medium-term financials: so growth and potential commercial value, and we will \u2018pitch\u2019 for investment within the UK executive team.\u201d If the answer is yes, the product will remain in the Lab for between three and six months.\r\n\r\nGiddings also feels that the operation of this phase is unique to Time Inc. UK\r\n<blockquote>\u201cWe generate commercial (revenue) and growth targets. We are essentially building the bedrock of a fully-fledged product that we hand back to the business within an aggressive timescale.\u201d</blockquote>\r\nMost people would hand a product over at incubation stage, so for us to manage that element is a very different way of working,\u201d he adds.\r\n\r\nIf the concept continues to operate successfully, the digital offering will enter \u2018propagation\u2019.\r\n\r\nPropagation - This is a new phase, the ambition for which is to eventually see the products the Lab has launched handed back to the business alongside growth plans, audience personas, resource and staffing requirements, a three-year plan for revenue generation and content briefs and analytics report. The business then takes control.\r\n\r\n&nbsp;\r\n<h3>Products</h3>\r\nThis approach has resulted a number of new digital products - some independent of the legacy business, but others wrap around existing offerings \u201cFrom a build perspective, due the resource required, we only build what we need.\u201d\r\n\r\n<img class=\"wp-image-10162 size-full aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/nme_d_phone.png\" alt=\"\" width=\"856\" height=\"1500\" />NME Daily - Based on consumer insights that pointed towards short form and daily music news and info, the app is a free product. However, the analytics and data is something of real interest to the Lab. Using Facebook registration, the connects with Spotify and harnesses individuals and their network\u2019s data. Giddings explains that as a result of this \u201cwe can start to get real time listening habits, which, instead of being an authoritative voice to broadcast, we can listen to what the audience wants and start creating content around this. All of those things go back to the needs the audience gave us.\u201d\r\n\r\n<img class=\"wp-image-10159 size-full aligncenter\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/live-smart_1.png\" alt=\"\" width=\"1217\" height=\"764\" />\r\n\r\nLive-Smart.co - A commissioned yougov poll disicered that although 84% of people had heard of smart tech, around 40% didn\u2019t know what it was. This mapped against a potential business opportuntity for the Lab as smart tech and Internet of Things devices are predicted to be a huge growth market over the next five to ten years. This site offers Smart tech news and information but in an accessible and relevant way. Headlines include \u2018Your standing desk is missing this giant DIY hamster wheel\u2019, \u2018FenSens add-on parking sensor saves you from parking bumps\u2019, \u2018<a href=\"http://www.live-smart.co/news/home-patrolling-robot-9158\">This Home Patrolling Robot is like a cyber guard dog you can control from afar\u2019.</a>\r\n\r\n&nbsp;\r\n<h3>Lab people</h3>\r\nThe rapid nature of development and multiplatform development requires the core team to have a wide-array of skills - Giddings is often referred to as a Swiss Army Knife. The Innovation Lab also pulls in skills as and when needed on a product-by-product basis. This also leads onto a number of key challenges the Lab faces.\r\n\r\n\u2018It\u2019s about finding the right resource to work in a lab,\u201d Giddings explains.\r\n<blockquote>\u201cPeople see it as a really cool and really sexy part of the business, but actually, it\u2019s really hard work. You need to be constantly learning and keeping your eye on new things, both from an external perspective - so new tech and markets - and in having your ear to the ground and knowing exactly where the business is going.\u201d</blockquote>\r\nNevertheless, despite the challenges, he\u2019s excited about the future of the Lab and the wider digital publishing sector.\r\n<blockquote>\u201cThe web is such an amazing place - there are so many things that you can build with little or no coding knowledge that allow you to text products very very quickly that look brilliant\u2026\u201d</blockquote>\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n&nbsp;\r\n\r\n<img class=\"alignnone size-full wp-image-10164\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/richard-giddings.jpg\" alt=\"\" width=\"200\" height=\"250\" />\r\n\r\nRich Giddings, head of product development, Time Inc UK Innovation Lab\r\n\r\nWeb:\u00a0<a href=\"http://www.timeincuk.com/\">timeincuk.com</a>\r\n\r\nTwitter: <a href=\"https://twitter.com/TimeIncUK\">@timeincuk</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Time Inc UK Innovation Lab: accelerated product development","post_link":"https://media-innovation.news/media-lab/time-inc-uk-innovation-lab-accelerated-product-development/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Time Inc UK Innovation Lab: accelerated product development\" width=\"300\" height=\"167\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/lab_1-300x167.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"design sprint, insights, lean development, prototypes, rapid product development, UK","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1532420997:101","%_edit_last%":"101","%_thumbnail_id%":"10156","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_item_likes%":"0","%_kleo_title_checkbox%":"1","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_content_score%":"30","%_wpgmp_location_address%":"Time Inc UK Ltd, Farnborough, United Kingdom","%_wpgmp_metabox_latitude%":"51.284782","%_wpgmp_metabox_longitude%":"-0.7625679999999875","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1544884609,"payload":[{"id":10201},{"id":10754},{"id":10776}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"design sprint, insights, lean development, prototypes, rapid product development, UK"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10155,"infowindow_disable":false},{"source":"post","title":"Drone Journalism Lab: action research and innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Drone Journalism Lab: action research and innovation\" width=\"300\" height=\"187\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Drone-and-Ben-small-300x187.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Drone Journalism Lab: action research and innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The Lab\u2019s work is to equip journalists and the wider industry with the skills and knowledge they\u2019ll need for the future\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/drone-journalism-lab-action-research-and-innovation/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The Lab\u2019s work is to equip journalists and the wider industry with the skills and knowledge they\u2019ll need for the future","address":"University of Nebraska-Lincoln College of Journalism and Mass Communications, Lincoln, Nebraska, United States","location":{"lat":"40.8152976","lng":"-96.69922680000002","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/drone-journalism-lab-action-research-and-innovation/","zoom":2,"extra_fields":{"post_excerpt":"The Lab\u2019s work is to equip journalists and the wider industry with the skills and knowledge they\u2019ll need for the future","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]\r\n<h1><strong>Drone Journalism Lab: action research and innovation\u00a0</strong></h1>\r\n<strong>Nebraska-Lincoln\u2019s College of Journalism and Mass Communication\u2019s Drone Journalism Lab was established in 2011 with a remit to explore drones and journalism. It was prompted by a chance meeting between a man and a drone.</strong>\r\n\r\nFounder Matt Waite\u2019s encounter with an X100 at a Digital Mapping Conference five years ago prompted him to realise the potential for drones and journalism to cover powerful stories. He also realised that students and journalists could benefit from real-world and open research into how UAVs could be developed used as a journalistic tool.\r\n<blockquote>\u201cI walked to the guy who was selling these things\u201d, Waite explains, \u201cand I handed my wallet. I said \u2018I will take that one\u2019. The guy laughed and gave me my wallet back. He said \u2018well, they cost about $65,000 dollars each. Oh, and by the way, they are completely illegal in the United States.\u2019\u201d</blockquote>\r\nNevertheless, Waite was unperturbed.\r\n<blockquote>\u201cI realised that journalists were going to use drones and they were going to be an important tool in a series of stories. But I could already see that this was going to cause problems. There were going to be new questions of privacy, ethics and training.\"</blockquote>\r\nAfter pitching the concept of a Drone Lab to his Dean and Faculty and with funding from Knight Foundation, Waite recruited \u201ctalented students\u201d and has since explored drone journalism, virtual reality, 3D mapping and UAV-generated data journalism.\r\n\r\n&nbsp;\r\n<h3>New skills and new technologies</h3>\r\nA key motivation for the Lab\u2019s work is to equip journalists and the wider industry with the skills and knowledge they\u2019ll need for future work. Waite suggests that drones being part of a \u00a0journalist\u2019s toolkit would need them to expand their knowledge and skills for situations they\u2019ve never before encountered. Safety and aviation regulations are just two of these areas.\r\n\r\nAs the FAA\u2019s regulation prevent UAV use without a full pilot\u2019s licence,Waite explains: \u201cI thought the Lab would be a good thing. It would be one of the first times that journalists could see a technology coming, be able to sit and figure out how we are going to use it, before we can use it.\u201d\r\n\r\nWaite also suggests that there is scope for drones to move beyond simple video or image capture. Talking about a project at Nairobi dump Dandora with student Ben Kreimer (now a BuzzFeed Open Lab Fellow) and African SkyCam, where the team captured and mapped 3D virtual environments of the dump - where people live alongside the dump and scavenge a living from it - and overlaid story narratives.\r\n<blockquote>\u201cIf you go to <a href=\"http://benkreimer.com/aerial-video-photography/nairobi-dandora-dumpsite-video-3d-model/\">Ben\u2019s website</a> you can actually find the 3D model for it. In a browser you can go there and suddenly your browser is the drone. You can fly around the dump and go see different parts. Because it is a digital file, you can annotate certain spots in the dump and you click on it and it takes you to a school that is right next to it, and a place where people live, and the Nairobi river, and another school on the other side of the dump.\"</blockquote>\r\nThis \u201cfirst foray\u201d into the world of mapping and 3D visualisation, prompted Waite to decide this \u201cwas the place where drones are going to be useful\u201d.\r\n\r\n&nbsp;\r\n<h3>Regulation and Innovation</h3>\r\nHowever, the Drone Journalism Lab has hit fundamental issues around its ability to both study innovation and innovate within their specific field: legislative frameworks. The Federal Aviation Authority\u2019s regulatory framework prevents individuals from flying drones for commercial activities with express authorisation. Waite himself went through a full pilot training programme, and is still waiting for sign off from the FAA to fly drones nine months later.\r\n\r\nAs such, the Lab\u2019s capacity to test drone platforms and create stories has been severely limited. Their response is to travel to parts of the world where they can innovate within the legal frameworks, and collaborate with local partners: \u201cOur drones have flown in India, Turkey, Tanzania, Kenya and Dubai. We have been able to keep doing things through partnerships with other people, but none of it has been here in the U.S. because we cannot.\"\r\n\r\nHowever, after gaining a pilot\u2019s licence, Waite is hopeful that more projects will be undertaken in the US.\r\n<blockquote>\u201cNow that we are very close to having permission to do this openly and legally in the United States, we have got a number of projects in the pipeline. We will be working with news organizations on stories, we will be working with entities on multimedia storytelling. We are going do some virtual reality, data mapping and things like that.\"</blockquote>\r\n&nbsp;\r\n<h3>Recruitment</h3>\r\nThe main contributors to the Lab have been students within Nebraska-Lincoln\u2019s College of Journalism and Mass Communication, who have worked with Matt on a range of projects, and some of which have gone on to develop professional expertise beyond their degree. Ben Kreimer is a notable example.\r\n\r\nWaite suggests that his Lab can benefit from a wide range of skills, but they element for any student engaging with the lab is curiosity.\r\n<blockquote>\"Above all else, I am looking for curious people. I am looking for the kind of curious person that gets interested in something and then just does not wanna stop working on it and does not like just leave it alone, they are not the kind of person who can just drop something and forget about it.\u201d</blockquote>\r\n&nbsp;\r\n<h3>The Future</h3>\r\nWithin journalism, Waite suggests that drones will be used to capture images, video and be particularly interesting in break news situations. However, he\u2019s most excited about combining drone-drive data and journalism. Regulations permitting, he says \u201cthe imagination and innovation is going come from gathering data on environments and our communities - modelling that with other data on the ground and combining it into new and interesting things\u201d.\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone wp-image-10595 size-full\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Matt-Waite-e1495634869979.jpg\" alt=\"\" width=\"200\" height=\"256\" />\r\n\r\nProfessor Matt Waite, Founder, Drone Journalism Lab\r\nWeb:\u00a0<a href=\"http://www.dronejournalismlab.org/http://www.dronejournalismlab.org/\">dronejournalismlab.org</a>\r\nTwitter:<a class=\"ProfileHeaderCard-screennameLink u-linkComplex js-nav\" href=\"https://twitter.com/mattwaite\">@<span class=\"u-linkComplex-target\">mattwaite</span></a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Drone Journalism Lab: action research and innovation","post_link":"https://media-innovation.news/media-lab/drone-journalism-lab-action-research-and-innovation/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Drone Journalism Lab: action research and innovation\" width=\"300\" height=\"187\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Drone-and-Ben-small-300x187.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"drone journalism, future skills, USA","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1517438762:1","%_edit_last%":"1","%_oembed_aa43f6922e46ac50182088ab4d21a2b1%":"{{unknown}}","%_item_likes%":"0","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_title_checkbox%":"1","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_thumbnail_id%":"10219","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_content_score%":"30","%_wpgmp_location_address%":"University of Nebraska-Lincoln College of Journalism and Mass Communications, Lincoln, Nebraska, United States","%_wpgmp_metabox_latitude%":"40.8152976","%_wpgmp_metabox_longitude%":"-96.69922680000002","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545525946,"payload":[{"id":11024},{"id":10681},{"id":11032}]}},"taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"drone journalism, future skills, USA"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10152,"infowindow_disable":false},{"source":"post","title":"Knight Lab at Northwestern: Q&#038;A with Professor Joe Germuska","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Knight Lab at Northwestern: Q&#038;A with Professor Joe Germuska\" width=\"300\" height=\"158\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Knight-Lab-lead-image-300x158.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Knight Lab at Northwestern: Q&#038;A with Professor Joe Germuska</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Northwestern University Knight Lab builds software that helps inform and engage the public\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/qa-with-professor-joe-germuska-chief-nerd-knight-lab-at-northwestern/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Northwestern University Knight Lab builds software that helps inform and engage the public","address":"Northwestern University Knight Lab, Sheridan Road, Evanston, IL, United States","location":{"lat":"42.0506909","lng":"-87.6741599","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/qa-with-professor-joe-germuska-chief-nerd-knight-lab-at-northwestern/","zoom":2,"extra_fields":{"post_excerpt":"Northwestern University Knight Lab builds software that helps inform and engage the public","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]\r\n<h1>Knight Lab at Northwestern: Q&amp;A with Professor Joe Germuska</h1>\r\n<strong>Northwestern University Knight Lab builds software that helps inform and engage the public. Their projects range from professionally developed products used by newsrooms around the world to experimental prototypes that predict voting behaviour, recommend content, and track political rhetoric.</strong>\r\n\r\n\"Knight Lab was founded in 2011 with a generous grant from the Knight Foundation. However, the actual work that Knight Lab does today has diverged considerably from some of the original intentions,\" says Joe Germuska.\r\n\r\nAs a Lab, not every idea grows into a full-blown product. Some ideas are born, built, and die before being released to the public. Others move from a proof-of-concept built by students in a Northwestern classroom to the Lab for professional development and design and are then used by media makers around the world.\r\n\r\n<strong><i>Is there a specific challenge or thematic area that your projects focus on?</i></strong>\r\n\r\n<span style=\"font-weight: 400;\">We try to remain open to pursuing various faculty and staff research areas, so we don\u2019t have a strict list of times or challenges. I think in short, we are interested in media design for the 21st century, taking into account new, ever cheaper devices for consuming, producing and distributing media. By design we mean best practices for successful storytelling and clear communication, adapting principles which are well understood to these new forms.</span>\r\n\r\n<span style=\"font-weight: 400;\">A little more specifically, we have people who are very interested in the future of visual storytelling, including Virtual Reality, Drone photography, and other advanced cameras and in platform-specific best practices for new forms such as Snapchat, Instagram, and Amazon Echo. One of my personal project areas is in bridging the gap between \u201copen\u201d data and \u201cusable\u201d data. Of course we also have a number of </span><a href=\"https://projects.knightlab.com/#toolbox\"><span style=\"font-weight: 400;\">very popular tools for storytellers</span></a><span style=\"font-weight: 400;\">, and we are always interested in creating more, when we find a promising path.</span>\r\n\r\n<strong><i>How many people work inside?</i></strong>\r\n\r\n<span style=\"font-weight: 400;\">Knight Lab has four founding faculty members, two from Engineering and two from Journalism. We also have two closely affiliated Journalism professors who have gotten involved with us since the original grant. I am not on the University faculty, but instead have a staff appointment. After me, there are three full time software developer positions and a communications manager. We also work with a number of students: we have about 12 undergraduate student fellows, and loose relationships with 3-4 graduate students. Also, this quarter, there is an academic class of five students who are physically working in the lab some of the time, and who are in some ways part of the community. </span>\r\n\r\n<strong><i>I see you have funding from the Knight Foundation, the National Science Foundation and the Robert McCormick Foundation. Do you work with any other external forms of financing, for the lab or for specific projects?</i></strong>\r\n\r\n<span style=\"font-weight: 400;\">Up to now, we have not secured project-specific funding. It\u2019s certainly something we\u2019re open to, but it hasn\u2019t happened yet.</span>\r\n\r\n<strong><i>What types of clients do you work with, generally?</i></strong>\r\n\r\n<span style=\"font-weight: 400;\">Our work is not exactly client-driven, at least compared to my experience in other software development environments. We\u2019ve done less partnering than was suggested in the original grant announcement, but we are renewing our efforts to find good media and technology partners.</span>\r\n\r\n<strong><i>Do you work with any news desk? If so, how close to them would you say is the process?</i></strong>\r\n\r\n<span style=\"font-weight: 400;\">This has not happened much so far, but as mentioned above, we are beginning to experiment with media/content partners. It\u2019s too soon to really characterize the process, but I will say that one of the reasons that I think the lab stepped away from the first approach to partnering was that they weren\u2019t close enough \u2014 in the software development world I came from, committed stakeholders are critical to success, but often times, people look at Universities as a source of free labor instead of a true partner. </span>\r\n\r\n<strong><i>After the team releases a product/project, do you discuss or follow how was its adoption by the newsroom or audience?</i></strong>\r\n\r\n<span style=\"font-weight: 400;\">We monitor Google Analytics for basic usage, and we do some surveys, and we also sometimes analyze data created by people as they use our tools for more insight into how they are using it and which features are more or less popular, or more or less well-understood.</span>\r\n\r\n<strong><i>How would you describe the innovation process and methods inside the lab?</i></strong>\r\n\r\n<span style=\"font-weight: 400;\">We try to communicate a lot with each other about what\u2019s interesting and what\u2019s possible. We frequently experiment with new forms for getting that creative exchange, like community lunches with outside guests, occasional sessions where we deliver brief \u201clightning talks\u201d to each other, and other ways of getting feedback and sharing information. We are also looking to some possible new models of linking work that happens in the lab with other academic work, so that students would work on lab-directed projects for course credit\u2014the model we have in mind is very much inspired by how engineering research labs work, but we need to make adaptations all the time!</span>\r\n\r\n<span style=\"font-weight: 400;\">CONTACT POINT</span>\r\n\r\n<img class=\"alignnone\" src=\"https://media.licdn.com/mpr/mpr/shrinknp_200_200/p/3/000/022/1ad/2df2950.jpg\" alt=\"\" width=\"200\" height=\"200\" />\r\n\r\n<span style=\"font-weight: 400;\">Professor Joe Germuska, Chief Nerd, Knight Lab at Northwestern University </span>\r\n<span style=\"font-weight: 400;\">Web: </span><a href=\"http://knightlab.northwestern.edu/\"><span style=\"font-weight: 400;\">http://knightlab.northwestern.edu/</span></a>\r\n<span style=\"font-weight: 400;\">Twitter: </span><a href=\"https://twitter.com/JoeGermuska\"><span style=\"font-weight: 400;\">@JoeGermuska</span></a>\r\n\r\n<span style=\"font-weight: 400;\">Email: </span><a href=\"mailto:JoeGermuska@northwestern.edu\"><span style=\"font-weight: 400;\">JoeGermuska@northwestern.edu</span></a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Knight Lab at Northwestern: Q&#038;A with Professor Joe Germuska","post_link":"https://media-innovation.news/media-lab/qa-with-professor-joe-germuska-chief-nerd-knight-lab-at-northwestern/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Knight Lab at Northwestern: Q&#038;A with Professor Joe Germuska\" width=\"300\" height=\"158\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Knight-Lab-lead-image-300x158.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"academic Lab, Knight Foundation, public engagement, software, USA","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1517438831:1","%_edit_last%":"1","%_oembed_5950804ad65cce01330a42757f21be18%":"{{unknown}}","%_oembed_94e367168f68a7f429641fde2960970b%":"{{unknown}}","%_thumbnail_id%":"10149","%_item_likes%":"0","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_title_checkbox%":"1","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_content_score%":"30","%_wpgmp_location_address%":"Northwestern University Knight Lab, Sheridan Road, Evanston, IL, United States","%_wpgmp_metabox_latitude%":"42.0506909","%_wpgmp_metabox_longitude%":"-87.6741599","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545274089,"payload":[{"id":10681},{"id":10754},{"id":10144}]}},"taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"academic Lab, Knight Foundation, public engagement, software, USA"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10148,"infowindow_disable":false},{"source":"post","title":"NYC Media Lab: a public-private partnership for innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NYC Media Lab: a public-private partnership for innovation\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/NYC-Media-Lab-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media clusters</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">NYC Media Lab: a public-private partnership for innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            NYC Media Lab unites New York City-based companies, researchers and students to drive digital media development by creating an \u2018open innovation ecosystem\u2019\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/nyc-media-lab-a-public-private-partnership-for-innovation/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"NYC Media Lab unites New York City-based companies, researchers and students to drive digital media development by creating an \u2018open innovation ecosystem\u2019","address":"Media Labs FDNY, MetroTech Center, Brooklyn, NYC, NY, United States","location":{"lat":"40.6942697","lng":"-73.9844382","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/nyc-media-lab-a-public-private-partnership-for-innovation/","zoom":2,"extra_fields":{"post_excerpt":"NYC Media Lab unites New York City-based companies, researchers and students to drive digital media development by creating an \u2018open innovation ecosystem\u2019","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]\r\n<h1>NYC Media Lab: a public-private partnership for innovation</h1>\r\nNYC Media Lab unites New York City-based companies, researchers and students to drive digital media development by creating an \u2018open innovation ecosystem\u2019. It employs a range of methods to foster and facilitate this innovation, but its core is to assist higher education and digital media and communications organisations to engage and collaborate.\r\n\r\nEstablished in 2010 by the New York City Economic Development Corporation, Columbia University and New York University, and with a core staff of three, the Lab acts as the hub of a consortium now combining knowledge seven universities and 18 media, telecoms or start-up companies. Collaborators and partners include Bloomberg, Audible, ESPN, Hearst and AP.\r\n\r\nThe Lab attracts funding from a range of sources spanning private and public money - for example, it can charge media companies between $50,000 and $250,000 to work on projects and connect them with skills and expertise from their community and network. It currently operates across four key areas.\r\n<ul style=\"list-style-type: disc;\">\r\n \t<li>Data science and media</li>\r\n \t<li>Virtual and augmented reality</li>\r\n \t<li>Internet of Things and Media</li>\r\n \t<li>Design and User Experience</li>\r\n</ul>\r\nJustin Hendrix, executive director of the Lab, explains the nature of the applied research and development, and rationale for how the partners come together.\r\n\r\n\u201cWe work with faculty and students on the campuses across a range of disciplines that touch media and communications\u2026 typically on projects of the inner section of the interests of technologies, product or innovation people in the companies.\u201d\r\n\r\nHendrix says that a uniting element behind these collaborations is a \u201cshared curiosity\u201d, adding that \u201csometimes that\u2019s around disciplines like the data sciences, sometimes it\u2019s around, you know, augmented and virtual reality, sometimes it\u2019s around user experience and UI, sometimes it\u2019s around some other discipline\u201d.\r\n\r\n<a title=\"Visions of the Connected Home\" href=\"https://www.flickr.com/photos/nycmedialab/20356122800/in/dateposted/\" data-flickr-embed=\"true\"><img src=\"https://c1.staticflickr.com/6/5823/20356122800_3f360d260e_z.jpg\" alt=\"Visions of the Connected Home\" width=\"640\" height=\"427\" /></a><script src=\"//embedr.flickr.com/assets/client-code.js\" async=\"\" charset=\"utf-8\"></script>\r\n\r\nOur projects are with students who are in design and technology programs, or who are in engineering programs that specifically touch media. The range of disciplines is pretty extraordinary\r\n\r\n\u201cWhatever a media company could be curious about with regard emerging technologies we can go out and find a partner on New York City\u2019s campuses to help them explore that idea.\u201d\r\n\r\n&nbsp;\r\n<h3>Innovation methodologies</h3>\r\n\"We don\u2019t have a single methodology\", Hendrix explains. \"When we are working with an engineering school it\u2019s different than with a design school.\"\r\n\r\nThis is due to the wide range of interest areas, research and development challenges, and the skills within the network. The Lab bases each collaboration around those involved, and the goals of the project.\r\n\r\nAs a result of this multi-disciplinary approach, the Lab concentrates of the structures that exist around the projects, particularly for analysing their outcomes. Hendrix describes this process as generating a \u2018service blueprint\u2019, which allows the lab to understand work and results when both are particularly experimental.\r\n\r\n&nbsp;\r\n<h3>Project examples</h3>\r\nThere a broad range of media and technology projects that have emerged from the Lab. These span<a href=\"http://www.nycmedialab.org/mlbam-automatic-video-annotation/\">\u00a0\u2018Automatic Video Annotation\u2019</a>,\u00a0<a href=\"http://www.nycmedialab.org/projects/data-for-good/\">\u2018Data for Good\u2019</a>,\u00a0<a href=\"http://www.nycmedialab.org/projects/nbcuniversals-ncredible/\">social news games</a>\u00a0and\u00a0<a href=\"http://www.nycmedialab.org/projects/hearst-fellows-challenge/\">personalised product experiences</a>.\r\n\r\nHowever, Hendrix highlights the Lab\u2019s newest project as one that demonstrates its approach and values. The Combine is an accelerator programme for students, faculty staff and affiliated entrepreneurs to generate start-up media or technology concepts and move quickly to commercialisation. A total of nine teams from five university campuses will run through a \u2018lean\u2019 development process for six months and have access to a $25,000 grant.\r\n\r\nThe NYC Media Lab also provides a three-month curriculum for those in the programme centred on market validation, customer intelligence and how to development a minimum viable product. They will also have and access to companies and industry mentors.\r\n\r\nHendrix says: \u201cWe really believe is working about that is that because we have this mentor pool from the member companies, we are able to connect up the teams with great mentors from the industry, and that sets it apart.\u201d\r\n\r\nFollowing this phase, the start-ups will pitch to enter the incubation phase - and continue to develop their commercial offering.\r\n\r\nThe Combine is supported by New York City Economic Development Corporation, The Mayor\u2019s Office for Media and Entertainment and the NYC Media Lab\u2019s corporate membership.\r\n\r\nTo learn more about the NYC Media Lab -\u00a0<a href=\"http://www.nycmedialab.org/\">head over in this direction\u00a0</a>\r\n\r\nFor some info on The Combine,\u00a0<a href=\"http://www.thecombine.nyc/\">then you need to be here\u2026</a>\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n&nbsp;\r\n\r\n<img class=\"alignnone size-full wp-image-10593\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/AAEAAQAAAAAAAAXgAAAAJGQ4YmUzMDA4LTA5OTctNDRhMC1hZGQ1LTkwZjIzN2RhYjIxMQ.jpg\" alt=\"\" width=\"299\" height=\"299\" />\r\n\r\nJustin Hendrix, executive director\r\n\r\nWeb:\u00a0<a href=\"http://www.nycmedialab.org/\">nycmedialab.org</a>\r\n\r\nTwitter: <a href=\"https://twitter.com/justinhendrix?lang=en-gb\">@justinhendrix</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"NYC Media Lab: a public-private partnership for innovation","post_link":"https://media-innovation.news/media-lab/nyc-media-lab-a-public-private-partnership-for-innovation/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NYC Media Lab: a public-private partnership for innovation\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/NYC-Media-Lab-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media clusters","post_tags":"augmented reality, cluster, data science, design, internet of things, multidisciplinary, open innovation, partnerships, personalisation, public-private innovation, USA, UX, virtual reality","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1517438967:1","%_edit_last%":"1","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_title_checkbox%":"1","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_item_likes%":"0","%_thumbnail_id%":"10147","%_oembed_ad7215ddfe46c9232be00b7229b91fca%":"{{unknown}}","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"","%_wpgmp_location_address%":"Media Labs FDNY, MetroTech Center, Brooklyn, NYC, NY, United States","%_wpgmp_metabox_latitude%":"40.6942697","%_wpgmp_metabox_longitude%":"-73.9844382","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545319653,"payload":[{"id":10681},{"id":11815},{"id":11024}]}},"taxonomy=category":"Innovation Case, Media clusters","taxonomy=post_tag":"augmented reality, cluster, data science, design, internet of things, multidisciplinary, open innovation, partnerships, personalisation, public-private innovation, USA, UX, virtual reality"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10144,"infowindow_disable":false},{"source":"post","title":"Stibo Accelerator: inviting students and startups to help boost creativity and innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stibo Accelerator: inviting students and startups to help boost creativity and innovation\" width=\"300\" height=\"77\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Stibo-1-300x77.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Stibo Accelerator: inviting students and startups to help boost creativity and innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Inviting students and startups in to help boost creativity and innovation\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/stibo-accelerator/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Inviting students and startups in to help boost creativity and innovation","address":"Stibo Systems, Axel Kiers Vej, H\u00f8jbjerg, Denmark","location":{"lat":"56.10914499999999","lng":"10.162713800000006","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/stibo-accelerator/","zoom":2,"extra_fields":{"post_excerpt":"Inviting students and startups in to help boost creativity and innovation","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Stibo Accelerator: inviting students and startups to help boost creativity and innovation</h1>\r\nThe Stibo Accelerator is founded by Stibo A/S, the owner of news industry software solution providers, CCI and Escenic. The initiative, based in H\u00f8jbjerg, Denmark, is aimed at inviting talented, creative students to write their Master Thesis together with CCI/Escenic and the company\u2019s network of partners, customers, suppliers and industry experts. The Accelerator supports the students by creating the optimal conditions for them to investigate new technologies and trends in the news industry.\r\n<h3><b><img class=\"aligncenter wp-image-10140\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Stibo-2.jpg\" alt=\"\" width=\"486\" height=\"324\" />\r\nWhat\u2019s in it for the hosting company?</b></h3>\r\n<span style=\"font-weight: 400;\">Students and startups are some of the most innovative and out-of-the-box-thinking folks around, and CCI\u2019s staff is continuously challenged and sharpened by the new ideas the Accelerator teams bring out through their projects. </span>\r\n<h3><b><img class=\"aligncenter wp-image-10141\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Stibo-1.jpg\" alt=\"\" width=\"962\" height=\"246\" /></b></h3>\r\n<h3><b>Projects so far</b></h3>\r\n<span style=\"font-weight: 400;\">Since the Stibo Accelerator was launched in 2014 the initiative has graduated 22 innovation projects by 49 students from 7 different academic institutions. 2 startups have been incubated and are now self-sustaining businesses. </span>\r\n\r\n&nbsp;\r\n<h3><b>Examples of trends and technologies investigated</b></h3>\r\n<ul>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Autonomous Drone investigative storytelling platform</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Smart Home as a news source</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Reinventing the printed product (personalization and inductive ink)</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Chat Bots for local news publishers</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Personal data as payment model for news</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Mobile \u201cMicro Moments\u201d for magazine publishers</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Non-news online behavior data for creating better news recommendations</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">SnapChat as a news channel for 15-25 year-old</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Google Glass for news</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">iBeacons for geolocation based advertising</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">News on Smart Watches</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Hyper-local urban e-ink news screens</span></li>\r\n</ul>\r\n&nbsp;\r\n\r\n<span style=\"font-weight: 400;\">See all projects at <a href=\"http://www.stiboaccelerator.com\">stiboaccelerator.com</a></span>\r\n\r\n&nbsp;\r\n<h3><b>The Stibo Accelerator model</b></h3>\r\n<span style=\"font-weight: 400;\">A key to all of the projects is the close collaboration with partners. This means that the projects are </span><i><span style=\"font-weight: 400;\">not </span></i><span style=\"font-weight: 400;\">run with CCI/Escenic as case partner but with the company\u2019s customers directly. The Stibo Accelerator facilitates the connection to publishers in the CCI/Escenic network and stay on the side-line, so to speak. This makes it possible to run many projects of high quality with very little staff (1 full time employee only). Here is an illustration of the so-called \u201ctumble dryer\u201d model used:</span>\r\n\r\n<b><img class=\"aligncenter wp-image-10138\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Stibo-4.jpg\" alt=\"\" width=\"862\" height=\"484\" /></b>\r\n<h3><b>Starting with project proposals</b></h3>\r\n<span style=\"font-weight: 400;\">The Stibo Accelerator is open to evaluate the potential in all projects pitched by students or startups, but instead of waiting around for students to come up with their own ideas, a catalogue of ideas is sent to the partnering universities before each season begins. See the current \u201cproject proposals\u201d here:</span>\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://www.stiboaccelerator.com/#!project-ideas/k9k5k\"><span style=\"font-weight: 400;\">http://www.stiboaccelerator.com/#!project-ideas/k9k5k</span></a>\r\n\r\n&nbsp;\r\n\r\n<i><span style=\"font-weight: 400;\">(Note that the Stibo Accelerator also serves another Stibo business unit, Stibo Systems. That\u2019s the reason for the retail related project proposals)</span></i>\r\n\r\n&nbsp;\r\n\r\n<span style=\"font-weight: 400;\">In the previous seasons about 75% of the projects start with one of the topics proposed. But in all cases the project proposal is just a starting point. The students take their own angle to the topic when the research begins. </span>\r\n<h3><b>Using students to infuse innovation</b></h3>\r\n<span style=\"font-weight: 400;\">Regularly during the projects the students in the Accelerator are asked to participate is some form of internal meeting or staff session sharing their ideas and research findings with the CCI/Escenic staff. This way the students get valuable experience in presenting the business values in their ideas and the CCI/Escenic staff members are kept up to date with cutting edge trends and technologies. Often CCI/Escenic employees are recruited as mentors for the teams. This gives them the opportunity to discuss new business ideas directly with customers without having to only focus on \u201cwhat can be delivered in the next release of the software\u201d. It forms an inspiring creative bond between supplier and customer.</span>\r\n\r\n&nbsp;\r\n<h3><b>How much does it cost?</b></h3>\r\n<span style=\"font-weight: 400;\">The Stibo Accelerator is run by one full-time employee. Travel and other project cost is covered for the students, so the total price for running the Accelerator using the above mentioned models is about 1.5 full-time employees. In addition to this comes the room (a spare room is used, no rent is paid) and the free lunch and coffee also included for the teams. </span>\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone size-full wp-image-8661\" src=\"https://media-innovation.news/wp-content/uploads/2016/04/Kim-SVENDSEN.jpg\" alt=\"\" width=\"300\" height=\"400\" /></span>\r\n\r\n<span style=\"font-weight: 400;\">Kim Svendsen, Director, Stibo Accelerator </span>\r\n<span style=\"font-weight: 400;\">Web: </span><a href=\"http://www.stiboaccelerator.com/\"><span style=\"font-weight: 400;\">stiboaccelerator.com</span></a>\r\n<span style=\"font-weight: 400;\">Twitter: </span><a href=\"https://twitter.com/kimsvendsen\"><span style=\"font-weight: 400;\">@kimsvendsen</span></a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_column_text]\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>[/vc_column_text][/vc_column][/vc_row]","post_title":"Stibo Accelerator: inviting students and startups to help boost creativity and innovation","post_link":"https://media-innovation.news/media-lab/stibo-accelerator/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stibo Accelerator: inviting students and startups to help boost creativity and innovation\" width=\"300\" height=\"77\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Stibo-1-300x77.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"accelerator, Denmark, students","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1524063081:101","%_edit_last%":"101","%_thumbnail_id%":"10141","%_oembed_c6a114de09e14a4db4c3a973468e6df3%":"{{unknown}}","%_item_likes%":"0","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_title_checkbox%":"1","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"","%_wpgmp_location_address%":"Stibo Systems, Axel Kiers Vej, H\u00f8jbjerg, Denmark","%_wpgmp_metabox_latitude%":"56.10914499999999","%_wpgmp_metabox_longitude%":"10.162713800000006","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1544945711,"payload":[{"id":11494},{"id":10991},{"id":10783}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"accelerator, Denmark, students"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10137,"infowindow_disable":false},{"source":"post","title":"NTNU &#8211; Sense-IT","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NTNU &#8211; Sense-IT\" width=\"300\" height=\"201\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/NTNU-2-300x201.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">NTNU &#8211; Sense-IT</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            The Norwegian University of Science and Technology's Sense-IT Lab is exploring 3DTV, augmented media, immersive experiences and whole body interaction techniques\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/ntnu-sense-it/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"The Norwegian University of Science and Technology's Sense-IT Lab is exploring 3DTV, augmented media, immersive experiences and whole body interaction techniques","address":"Norwegian University of Science and Technology, H\u00f8gskoleringen, Trondheim, Norway","location":{"lat":"63.41949899999999","lng":"10.402077100000042","onclick_action":"marker","redirect_permalink":"https://media-innovation.news/media-lab/ntnu-sense-it/","zoom":2,"extra_fields":{"post_excerpt":"The Norwegian University of Science and Technology's Sense-IT Lab is exploring 3DTV, augmented media, immersive experiences and whole body interaction techniques","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]\r\n<h1>NTNU - Sense-IT</h1>\r\n<b></b><span style=\"font-weight: 400;\">Exploring 3DTV, augmented media, immersive experiences and whole body interaction techniques, Sense-IT at the Norwegian University of Science and Technology (NTNU) is main hub for the Department of electronics and telecommunications \u00a0research into sensor based digital storytelling and digital storytelling tools.</span>\r\n\r\n<span style=\"font-weight: 400;\">Initially created in 2003, the Lab formed part of the Norwegian National Centre of Excellence - Q2S (Quantifiable quality of service for communication system). Lab manager Professor Andrew Perkis describes its remit to explore and work within the intersection between art and technology. Its current focus is on sensor-based digital storytelling, and is made up of master, PhD students and post-doc researchers.</span>\r\n\r\n<span style=\"font-weight: 400;\">Due to the multidisciplinary nature of the lab, those working these have a wide range of skills and approaches. These span computer science, signal processing, art and technology. However, these skills are also underpinned by creativity.</span>\r\n<h3></h3>\r\n<h3><b><img class=\"aligncenter wp-image-10132 size-full\" src=\"http://mediainnovation.news/wp-content/uploads/2016/06/NTNU-1.jpg\" alt=\"NTNU - 1\" width=\"451\" height=\"300\" /></b></h3>\r\n<h3><b>Projects and methods</b></h3>\r\n<span style=\"font-weight: 400;\">Perkis outlines a number of projects the lab has been involved in. Although each project involves its own unique approach and methodologies, he suggests that the uniting factor is that they are driven by \u201cexperimentation, piloting and demonstration\u201d.</span>\r\n\r\n<span style=\"font-weight: 400;\">Over a short to medium term, the work is driven by inquiries into user needs and interactions. When the research team is exploring longer-term strategies, this work is conducted amid a research-centric approach \u2013 i.e. establishing research questions within academic contexts and expertise. Both these elements are driven by the Lab\u2019s five-year research strategy.</span>\r\n\r\n<span style=\"font-weight: 400;\">Specific projects to either emerge from or include Sense-IT span</span>\r\n\r\n<a href=\"https://www.ntnu.no/parken\"><b>Adressaparken</b></a> <span style=\"font-weight: 400;\">\u2013 a new initiative in Trondheim to create a new interactive park space to allow people to come together to witness, learn about or engage with digital innovation. A partnership between the municipality of Trondheim, NTNU and regional newspaper Adresseavisen Adressaparken hopes to be a hub for creative technology and house permanent interactive art installations. It describes itself as an \u201c</span><span style=\"font-weight: 400;\">open arena for trying new expressions and new, digital forms of narrative. It should be a place to play, explore and learn \u2013 and to wonder, experience and relax\u201d.</span>\r\n\r\n<a href=\"http://www.qoenet-itn.eu/\"><b>QoENet</b></a><b> \u2013 innovative Quality Of Experience maNagement in Emerging MulTimedia services \u2013 </b><span style=\"font-weight: 400;\">This training network, funded by the European Commission for four years, focusses how people experience either delight or annoyance when engaging with digital services. Some of the areas under investigation include web TV, social and immersive TV and mobile gaming. NTNU is a partner in the project that spans seven countries - the network includes seven academic institutions, three companies and one standardization institute. The sense-IT lab and its methodologies play a crucial role in the work. The aims are to create methodological approaches and research frameworks for exploring quality of experience across disciplines spanning signal processing, communications, business, psychology and sociology.</span>\r\n\r\n<a href=\"https://www.ntnu.edu/artec\"><b>Artec</b></a><b> \u2013 </b><span style=\"font-weight: 400;\">NTNU\u2019s arts and technology task force, Artec is a cross-disciplinary collaboration within and beyond the university that champions research and artistic excellence. It does this through exploring the links between the humanities and technology. External partners include Adresseavisen and Trondheim municipality. </span>\r\n\r\n<a href=\"http://www.visualmediaproject.com/\"><b>VisualMedia</b></a><b> \u2013 This is an Innovation Action funded by the European Commission. The main topic is </b><span style=\"font-weight: 400;\">driven by industry requirements to continually improve audience engagement, VisualMedia is combining social media content with 3D graphics. It hopes to \u201cprovide broadcasters with the capability to manage complex and diverse data streaming in through the wide range of social media channels, and to translate this data into engaging interactive content for a better consumer experience\u201d.</span>\r\n<h3><b>Funding</b></h3>\r\n<span style=\"font-weight: 400;\">Funding for the Lab\u2019s activities comes from a range of sources. These include government and public funding, European funding structures \u2013 such as Horizon 2020 \u2013 and industry-funded research and development.</span>\r\n\r\n<span style=\"font-weight: 400;\">To find out more about the Lab and NTNU, <a href=\"http://www.iet-multimedialabs.org/senseit/\">head over in this direction</a></span>\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone\" src=\"http://www.wan-ifra.org/sites/default/files/imagecache/default_col_2/field_event_spkr_image/Andrew-Perkis.png\" width=\"140\" height=\"188\" />\r\n\r\n<span style=\"font-weight: 400;\">Professor Andrew</span><span style=\"font-weight: 400;\">\u00a0Perkis</span>\r\n\r\n<span style=\"font-weight: 400;\">Professor and Lab manager</span>\r\n\r\nTwitter: <a href=\"https://twitter.com/andrewperkis\">@andrewperkis</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>","post_title":"NTNU &#8211; Sense-IT","post_link":"https://media-innovation.news/media-lab/ntnu-sense-it/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NTNU &#8211; Sense-IT\" width=\"300\" height=\"201\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/NTNU-2-300x201.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"3DTV, augmented media, horizon 2020, Immersive, interaction, Norway","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1611686503:1","%_edit_last%":"1","%_thumbnail_id%":"10131","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_item_likes%":"0","%_oembed_c5a5a01fabd3b44682fee272f40b491c%":"{{unknown}}","%_kleo_title_checkbox%":"1","%_wpgmp_location_address%":"Norwegian University of Science and Technology, H\u00f8gskoleringen, Trondheim, Norway","%_wpgmp_metabox_latitude%":"63.41949899999999","%_wpgmp_metabox_longitude%":"10.402077100000042","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545348789,"payload":[{"id":11362},{"id":10144},{"id":11412}]}},"%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"3DTV, augmented media, horizon 2020, Immersive, interaction, Norway"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10130,"infowindow_disable":false},{"source":"post","title":"NxtMedia: a collaborative network for innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NxtMedia: a collaborative network for innovation\" width=\"300\" height=\"188\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/nxtmedia-conference-300x188.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media clusters</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">NxtMedia: a collaborative network for innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Harnessing multi-skilled networks in Norway and beyond to create internationally-recognised innovation\r\n\r\n\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/nxtmedia-a-collaborative-network-for-innovation/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Harnessing multi-skilled networks in Norway and beyond to create internationally-recognised innovation\r\n\r\n","address":"Trondheim, Norway","location":{"lat":"63.4305149","lng":"10.39505280000003","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/nxtmedia-a-collaborative-network-for-innovation/","zoom":2,"extra_fields":{"post_excerpt":"Harnessing multi-skilled networks in Norway and beyond to create internationally-recognised innovation\r\n\r\n","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]<i><span style=\"font-weight: 400;\">Harnessing multi-skilled networks for internationally-recognised innovation</span></i>\r\n\r\n<span style=\"font-weight: 400;\">Norwegian technology cluster NxtMedia seeks to stimulate journalism innovation through encouraging partnerships, research and product development across national and international media, technology and academic boundaries. Formed in 2011 and headquartered in Trondheim, NxtMedia supports personalized product development, data journalism initiatives and creating new narrative forms. The network identifies broad areas of interest, develop related technologies and seek and exploit commercial opportunities for both the technology and content.</span>\r\n\r\n<span style=\"font-weight: 400;\">Its key partners include regional newspapers Adresseavisen and </span><span style=\"font-weight: 400;\">Tr\u00f8nder-Avisa</span><span style=\"font-weight: 400;\">, the Norwegian Media Business Association, state broadcaster</span><span style=\"font-weight: 400;\"> NRK, media group Jysk Fynske Media (DK) and a variety of colleges, universities and technology companies from across the Trondheim area and beyond, the most prominent among them the national Norwegian University of Science and Technology (NTNU). </span>\r\n\r\n<span style=\"font-weight: 400;\">Rolf Dyrnes Svendsen, editor and chairman at NxtMedia, describes it as a \u201cproject enabler\u201d, with a core aim to foster collaboration across the sector to prompt and support innovation. Building, supporting and enabling the network is key, he adds.</span>\r\n<blockquote><span style=\"font-weight: 400;\">\u201cThe networking process brings together interested partners and builds\u00a0</span><span style=\"font-weight: 400;\">relations. The enabling process is identifying possibilities according to partner\u2019s and\u00a0</span><span style=\"font-weight: 400;\">member\u2019s interests and accelerate project from idea to execution,\u201d Svendsen continues.</span></blockquote>\r\n<span style=\"font-weight: 400;\">There are currently over 50 members and associates of the network, which is formed as an association, and two project managers. \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0</span>\r\n<h3></h3>\r\n<h3><strong>Methods, approaches and projects</strong></h3>\r\n<span style=\"font-weight: 400;\">NxtMedia is powered by two priorities: networking and enabling. Members of the network are drawn together around common goals or interest areas, and then supported in finding opportunities and resources to make projects happen.</span>\r\n\r\n<span style=\"font-weight: 400;\">Svendsen explains that the process \u201cidentifies possibilities according to partner\u2019s and member\u2019s interests and accelerate projects from idea to execution\u201d.</span>\r\n\r\n<span style=\"font-weight: 400;\">Collaboration between diverse partners is a key element of the process. \u201cAcademic and industrial groups work closely together, from the early analysis of technological needs to the deployment and evaluation of prototypes running on real data,\u201d Svendsen adds.</span>\r\n\r\nThroughout the networking, project development and execution, a broad range of research and development methods are used. Networking opportunities include the NxtMedia Conference and NODA data journalism conference, alongside more informal conversations such as seminars, breakfast meetings and academic events.\r\n\r\n<span style=\"font-weight: 400;\">Once a project is active and in a live research and innovation phase, the specific research methods are decided upon depending on the priorities of the project. For example RecTech (detailed below) uses Living Labs. This approach sees audiences and users provided with technologies in their own home or work environment. Researchers can then study a prototype or product\u2019s use and effectiveness in situ, rather than within a lab environment.</span>\r\n\r\n<span style=\"font-weight: 400;\">In addition to understanding users, researchers are also located within the media houses, so have a strong relationship with the newsroom and content creators.</span>\r\n\r\n<span style=\"font-weight: 400;\">Two specific projects to have emerged \u00a0under the personalized media recommendation</span> <span style=\"font-weight: 400;\">systems</span> <span style=\"font-weight: 400;\">area include</span><b> RecTech and Contextual</b><span style=\"font-weight: 400;\">.</span>\r\n\r\n<i><span style=\"font-weight: 400;\">RecTech</span></i><span style=\"font-weight: 400;\">, supported by the BIA program at the Research Council of Norway, is a large industry-led research project developing new approaches to deep content analysis and user intelligence for news recommendation. Over a four-year period, and with more than \u20ac4m, new components will be developed and deployed in a Living Lab environment via project partners Adresseavisen and NTNU. Other partners include data management firm Cxense and Technical Research Centre of Finland (VTT). </span>\r\n\r\n<i><span style=\"font-weight: 400;\">Contextual</span></i><span style=\"font-weight: 400;\">, funded by the FORNY programme at the Research Council of Norway, evaluates how elements of the recommender technologies can be commercialized.</span>\r\n\r\n<span style=\"font-weight: 400;\">Looking to the future of recommendation systems and describing NxtMedia\u2019s aspirations in this field, Svendsen points to global ambitions for rollout and market development. The \u201cvision is to be an international powertrain for this technology\u201d.</span>\r\n<h3><strong>Innovation and dissemination</strong></h3>\r\n<span style=\"font-weight: 400;\">NxtMedia\u2019s activities also move beyond creating new products and tools. It\u2019s interested in how innovation happens and explores innovation methods, processes and systems. This is potentially where NxtMedia\u2019s moves from creating a project to a deeper and long term commitment between partners and research and development areas.</span>\r\n\r\n<span style=\"font-weight: 400;\">It also seeks to tell people about its work and findings.</span>\r\n<blockquote><span style=\"font-weight: 400;\">\u201cIn 2013 we established an international workshop for researchers working on news recommender systems and news analytics, </span><i><span style=\"font-weight: 400;\">INRA</span></i><span style=\"font-weight: 400;\">. \u00a0INRA 2016, the Forth International Workshop on News Recommendation and Analytics, is held in conjunction with the 24</span><span style=\"font-weight: 400;\">th</span><span style=\"font-weight: 400;\"> Conference on User Modeling, Adaptation and Personalization (UMAP) in Canada.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cThe Norwegian Big Data Symposium (</span><i><span style=\"font-weight: 400;\">NOBIDS</span></i><span style=\"font-weight: 400;\">) was introduced by NxtMedia in 2015. The symposium, which serves as a meeting place for academic and industrial use of big data technologies in Norway, brings together big data communities to exchange ideas and experiences, as well as to discuss future collaboration and projects.\u201d</span></blockquote>\r\n<h3><strong>Intellectual property</strong></h3>\r\n<span style=\"font-weight: 400;\">However, before the collaboration, research, commercialization and dissemination can take place, Svendsen offers some advice to those involved in innovation networks or considering establishing them. on partnerships and intellectual property rights. He explains that, due to the differing priorities or academic and industry players, they may be in fundamentally different positions when it comes to IP and exploitation. The key element is for partners to figure these challenges out at the project\u2019s inception.</span>\r\n\r\n<span style=\"font-weight: 400;\">Svendsen explains: \u201cTo cooperate with publicly funded universities, research results must be open source, but products can be copyrighted. Research institutes and medialabs are different as they sell competence and technology transfers, but they can be important and positive partners in consortiums when applying for funding.</span>\r\n<blockquote><span style=\"font-weight: 400;\">\u201cThe important issue is to sort out the IPRs beforehand, but share as much as possible.\u201d</span></blockquote>\r\n<h3><b>Final words\u2026</b></h3>\r\n<span style=\"font-weight: 400;\">Despite the need to pin down IP, Svenden advises those innovating within the media sector to \u201cjust do it\u201d.</span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOpen up for partnership, identify friends who can help you along the digital highway and invest in long-time relationships.\u201d</span>\r\n\r\n<a href=\"http://nxtmedia.no/\"><span style=\"font-weight: 400;\">Explore NxtMedia\u2019s work </span></a>\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone\" src=\"http://events.wan-ifra.org/sites/default/files/styles/default_col_3_square/public/field_event_spkr_image/rolf.png?itok=t8DrKDPG\" width=\"220\" height=\"220\" />\r\n\r\n<span style=\"font-weight: 400;\">Rolf Dyrnes Svendsen, editor and chairman at NxtMedia, editor of\u00a0Adresseavisen</span>\r\n\r\ntwitter: @rods51<a href=\"https://twitter.com/Theophrasteio\">\r\n</a>web:\u00a0nxtmedia.no\r\n\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"NxtMedia: a collaborative network for innovation","post_link":"https://media-innovation.news/media-lab/nxtmedia-a-collaborative-network-for-innovation/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NxtMedia: a collaborative network for innovation\" width=\"300\" height=\"188\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/nxtmedia-conference-300x188.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media clusters","post_tags":"cluster, network, Norway","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1517439007:1","%_edit_last%":"1","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_item_likes%":"0","%_thumbnail_id%":"10121","%_oembed_00102414c46e1e75b64a2463f547f8d1%":"{{unknown}}","%_wpgmp_location_address%":"Trondheim, Norway","%_wpgmp_metabox_latitude%":"63.4305149","%_wpgmp_metabox_longitude%":"10.39505280000003","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1544758962,"payload":[{"id":11362},{"id":10130},{"id":10645}]}},"taxonomy=category":"Innovation Case, Media clusters","taxonomy=post_tag":"cluster, network, Norway"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10119,"infowindow_disable":false},{"source":"post","title":"Amaury Lab: a startup incubator led by a publisher","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Amaury Lab: a startup incubator led by a publisher\" width=\"300\" height=\"127\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Capture-d\u2019e\u0301cran-2016-06-14-a\u0300-10.50.33-300x127.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Amaury Lab: a startup incubator led by a publisher</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Amaury Lab brings together startups and entrepreneurs with the established Amaury Group publishing house to collaborate innovate, develop new projects and share creative approaches.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/amaury-lab-a-startup-incubator-led-by-a-publisher/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Amaury Lab brings together startups and entrepreneurs with the established Amaury Group publishing house to collaborate innovate, develop new projects and share creative approaches.","address":"10 Boulevard de Grenelle, 75015 Paris, France","location":{"lat":"48.8531923","lng":"2.2897027999999864","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/amaury-lab-a-startup-incubator-led-by-a-publisher/","zoom":2,"extra_fields":{"post_excerpt":"Amaury Lab brings together startups and entrepreneurs with the established Amaury Group publishing house to collaborate innovate, develop new projects and share creative approaches.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text]\r\n<h1>Amaury Lab: a startup incubator led by a publisher</h1>\r\n<span style=\"font-weight: 400;\"><strong>Amaury Lab brings together startups and entrepreneurs with the established Amaury Group publishing house to collaborate innovate, develop new projects and share creative approaches.</strong> </span>\r\n\r\n&nbsp;\r\n\r\n<em><strong>-- The Amaury Lab closed down since we talked to them in 2016 --</strong></em>\r\n\r\n&nbsp;\r\n\r\nThe Amaury Group is one of the largest publishers in France. Its brands include newspapers L\u2019Equipe and Le Parisien, advertising and branding arm Amaury Medias and a range of magazines.\r\n\r\nThe Lab is a place where new ideas and technologies can infuze innovation throughout the publisher, and beyond into the startup community. The results so far have included machine learning software, the exploration of new markets and internal change management.\r\n\r\n&nbsp;\r\n<h3><b>Startups and internal innovation</b></h3>\r\nThe Lab, established in 2014, functions by offering startup incubation opportunities - allowing them to grow their businesses. It provides office space and facilities without charge and access to internal data and systems. It is hoped that the products and services developed will assist with the startup\u2019s growth, and in Amaury\u2019s own innovation development.\r\n\r\nIt\u2019s work is, therefore, diverse. It spans data analysis solution, machine learning, artificial intelligence, social network monitoring and new interactive and immersive media products and experiences.\r\n\r\n&nbsp;\r\n<h3><b>Key products </b></h3>\r\n<span style=\"font-weight: 400;\">Nathalie Guicherd, innovation manager and head of the Amaury Lab, highlights a number of key products Amaury and its incubator Lab have launched. </span>\r\n\r\n<span style=\"font-weight: 400;\">She outlines the Lab\u2019s work with L\u2019Equipe\u2019s dedicated \u2018esports\u2019 tourna</span><span style=\"font-weight: 400;\">ment and related activities (Esports are video gaming competitions, which are popular in a number of markets globally, and are particularly active in South Korea. Earlier this year, </span><a href=\"https://newzoo.com/insights/articles/global-esports-market-report-revenues-to-jump-to-463-million-in-2016-as-us-leads-the-way/\"><span style=\"font-weight: 400;\">Newzoo suggested that esports</span></a><span style=\"font-weight: 400;\"> could be worth $463m in 2016 - a figure that demonstrates year-on-year growth of 43 per cent). </span>\r\n\r\n<span style=\"font-weight: 400;\">The Lab developed several tests to monitor esports\u2019 potential against L\u2019Equipe\u2019s audience and users. Once the esports programme was underway, it created a show on Channel l\u2019Equipe 21 to analyse e-sport trends and accompany the e-sport tournament.</span>\r\n\r\nHowever, the Lab has also worked on a number of other successful products. These include personalised newsletters that are generated using machine learning software, which are three times more successful than standard versions.\r\n\r\n&nbsp;\r\n<h3><b>Methods and processes </b></h3>\r\nThe Lab has a number of core elements to its work. These include forming local partnerships, creating individual support for the startups it works with, offering training for specific skills and needs, and conducting experiments in real world conditions within Amaury\u2019s operations.\r\n\r\n<span style=\"font-weight: 400;\">It also follows a four stage process for innovation activities: </span>\r\n<ol>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Analysing market innovation trends outside media </span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Monthly Innovation Committee shares learning with all managers. Those present look at a specific innovation topic and imagine how the teams could implement this topic and the potential effects for them.</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Open-innovation with key customers, partners and startups (i.e. strategic partnerships)</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Engaging with the startup incubator</span></li>\r\n</ol>\r\nWhen considering an innovation approach, Guicherd says that curiosity is key.\r\n<blockquote><span style=\"font-weight: 400;\">\u201cBe open to every single idea, test in reality, never say \u2018this won\u2019t work\u2019. Learn from every single failure. Don\u2019t think \u2018media only\u2019. Be curious from everything and share this mindset throughout the company.\u201d</span></blockquote>\r\n<span style=\"font-weight: 400;\">She adds that to pursue innovation, the concept of \u2018value for money\u2019 should be forgotten. Guicherd says that, from the perspective of a media group engaging with a startup community, it\u2019s important to understand startups and their ability to be agile. </span>\r\n\r\n<span style=\"font-weight: 400;\">Once in the lab, startups work closely with the various editorial operations. Guicherd outlines that there is a continuous conversation with the editorial operations to ensure the lab and the startups grasp how products and technologies are performing from an editorial perspective. </span>\r\n\r\n<span style=\"font-weight: 400;\">In terms of a specific process, the Lab undertakes market monitoring across a range of industries or sectors. They also test their concepts to generate learning on an operational level. \u00a0Openness is also at the core of their activities. \u201cOpen the doors to all startups, competitors to imagine new ideas, she says. \u201cInnovation is an issue for everyone, whatever his position or job.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">However, she does highlight challenges that the Lab faces. </span>\r\n\r\nGuicherd explains that the lab is also involved in \u201cdeep change management work\u201d. She argues that it is important to \u201calways explain, convince and show the results\u201d to ensure others within the group understand the work and impact of the startup collaborations.\r\n\r\n&nbsp;\r\n<h3><b>Short and long-term innovation </b></h3>\r\n<span style=\"font-weight: 400;\">The Lab aims to foster both short-term rapid development, but also operate over a longer-term basis. </span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cOur Startup incubator publishes two calls for application per year to the market to address specific strategic issues for the group, Guicherd explains. \u201cWe also monitor, meet and work with every new technology actor or producer - such as universities, platforms, startups, companies bringing new solutions to other markets to anticipate as many disruption subjects as possible.\u201d These disruptions could include data, new business models and new methods of innovation management.</span>\r\n\r\n&nbsp;\r\n<blockquote><span style=\"font-weight: 400;\">\u201cInnovation is an issue for everyone, whatever his position or job,\u201d she adds. </span></blockquote>\r\n<a href=\"http://www.amaurylab.amaury.com/\"><span style=\"font-weight: 400;\">For more information about Amaury Lab, head this way to their website</span></a><span style=\"font-weight: 400;\">. \u00a0</span>\r\n<h3>CONTACT POINT:</h3>\r\n<img class=\"alignnone wp-image-10205\" src=\"http://mediainnovation.news/wp-content/uploads/2016/06/Photo-N.-Guicherd.png\" alt=\"Photo N. Guicherd\" width=\"163\" height=\"163\" />\r\n\r\nNathalie Guicherd,\u00a0Innovation Manager, Head of Startup accelerator, Amaury Lab, France\r\n\r\nTwitter : <a href=\"https://twitter.com/nath_guicherd\">@Nath_Guicherd</a>\r\n\r\nLab Twitter: <a href=\"https://twitter.com/groupeamaurylab\">@groupeamaurylab</a>\r\n\r\nWeb:\u00a0<a href=\"http://www.amaurylab.amaury.com/\">www.amaurylab.amaury.com</a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_column_text][/vc_column_text][/vc_column][/vc_row]","post_title":"Amaury Lab: a startup incubator led by a publisher","post_link":"https://media-innovation.news/media-lab/amaury-lab-a-startup-incubator-led-by-a-publisher/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Amaury Lab: a startup incubator led by a publisher\" width=\"300\" height=\"127\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Capture-d\u2019e\u0301cran-2016-06-14-a\u0300-10.50.33-300x127.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"France, gaming, incubator, machine learning, personalisation, publishing house, sports, startups, training and education","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1532421116:101","%_edit_last%":"101","%_thumbnail_id%":"10202","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_item_likes%":"0","%_kleo_title_checkbox%":"1","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"","%_wpgmp_location_address%":"10 Boulevard de Grenelle, 75015 Paris, France","%_wpgmp_metabox_latitude%":"48.8531923","%_wpgmp_metabox_longitude%":"2.2897027999999864","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545514164,"payload":[{"id":10193},{"id":10766},{"id":11494}]}},"%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"France, gaming, incubator, machine learning, personalisation, publishing house, sports, startups, training and education"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10201,"infowindow_disable":false},{"source":"post","title":"Asahi Shimbun Media Lab: internal innovation","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Asahi Shimbun Media Lab: internal innovation\" width=\"300\" height=\"225\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Asahi-Media-Lab-Takeshita-Miyuki-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Asahi Shimbun Media Lab: internal innovation</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            An independent department for brainstorming and testing out new concepts using Asahi's existing skills and assets.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/10193-2/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"An independent department for brainstorming and testing out new concepts using Asahi's existing skills and assets.","address":"\u65e5\u672c\u6771\u4eac\u90fd\u4e2d\u592e\u533a\u7bc9\u5730\uff15\u4e01\u76ee\uff13\u2212\uff12 Asahi Shimbun Media Production \u682a\u5f0f\u4f1a\u793e \u671d\u65e5\u65b0\u805e\u30e1\u30c7\u30a3\u30a2\u30d7\u30ed\u30c0\u30af\u30b7\u30e7\u30f3","location":{"lat":"35.6639309","lng":"139.76562009999998","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/10193-2/","zoom":2,"extra_fields":{"post_excerpt":"An independent department for brainstorming and testing out new concepts using Asahi's existing skills and assets.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]\r\n<h1><b>Asahi Shimbun Media Lab: internal innovation</b></h1>\r\nJapan\u2019s Asahi Shimbun newspaper, founded in 1879, is one of the country\u2019s national newspapers. Its circulation, which was 6.6 million for its morning edition and 2.1 million for its evening edition as of April 2016, makes it the second most read newspaper in Japan and one of the most read newspapers in the world.\r\n\r\n&nbsp;\r\n\r\n<b>Origins of the Media Lab</b>\r\n\r\n<span style=\"font-weight: 400;\">Despite the circulation figures Asahi Shimbun\u2019s (literally translated as Rising Sun) former president Tadakazu Kumura was keen to create new revenue streams and new media innovation. The Asahi established a new strategic group - the Media Lab - to pursue these goals. Its mission statement is </span><i><span style=\"font-weight: 400;\">Beyond Media: steering away from the core business of Asahi Shimbun</span></i><span style=\"font-weight: 400;\">. \u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Unlike other Labs around the globe, Asahi\u2019s Lab doesn\u2019t pursue technological innovation. It sees itself as an independent department for brainstorming, testing out new concepts and providing a place where you are allowed to fail. Most of their work is an association of existing skills or an existing idea (sometimes from other industries) with a new twist.</span>\r\n\r\n&nbsp;\r\n<h3><b>Internal ideas, external engagement</b></h3>\r\nThe Asahi strongly believes that innovation doesn't always have to come from an external source. Indeed, new ideas and concepts can come from within the company, and all its staff are Asahi employees.. \"One should not overlook the expertise that a media company already has in-house\" says Miyuki Inoue, Business Developer, Researcher and Writer at The Asahi.\r\n\r\n<span style=\"font-weight: 400;\">However, this doesn\u2019t mean that the lab is closed. Since its inception, its members have worked with outside startups that offers alternative ideas and technologies. </span>\r\n<h3></h3>\r\n<h3><b>Projects:</b></h3>\r\n<span style=\"font-weight: 400;\">Today about 50 employees work for the lab. In combining existing resources from their traditional business with new ideas and concepts, they have launched several businesses over the past three years.</span>\r\n\r\n<span style=\"font-weight: 400;\">These include a crowdfunding platform, a website for pet news, an online education app, writing readers autobiographies, live streaming online education programmes or simply hosting hackathons.</span>\r\n\r\n<span style=\"font-weight: 400;\">The crowdfunding platform takes an existing idea (although from another type of business) and combines it with a publishing company's expertise (writing stories, interacting with their audience). This process was born from a simple brainstorming session and led by a group of a couple of employees for the testing phase. The service officially started from March 25, 2015.</span>\r\n\r\n<span style=\"font-weight: 400;\">Dozens of projects have been funded via the </span><a href=\"https://a-port.asahi.com/projects/whalemovie\"><span style=\"font-weight: 400;\">platform</span></a><span style=\"font-weight: 400;\">, with the highest amount raised hitting $200,000. </span>\r\n\r\n<span style=\"font-weight: 400;\">Another successful project is the </span><a href=\"http://lifestory.asahi.com\"><span style=\"font-weight: 400;\">'personal history project'</span></a><span style=\"font-weight: 400;\"> using existing retired reporters to write biographies of customers. The idea originally came from an employee during a brainstorm and was tested by the Lab. The feedback was good and users suggested that they would pay for the service. Following this successful feedback, it become a Asahi service from 1 September 2014. </span>\r\n\r\n<span style=\"font-weight: 400;\">Today 'personal history\u201d is the signature project of the lab.</span>\r\n<h3></h3>\r\n<h3><b>Key learnings: failure is not failure</b></h3>\r\n<span style=\"font-weight: 400;\">Products are not always a success: \"We tried to start a medical related service in collaboration with a group of doctors, but it eventually failed,\" said Miyuki.</span>\r\n\r\n<span style=\"font-weight: 400;\">The project appeared to be difficult to monetize and was abandoned. But the lab learned that once an initiative doesn\u2019t work, it should be dropped and replaced by a safer one as soon as possible. Miyuki suggests that 'Failure is not failure' in the lab, as long as a fast decision process is in place to avoid wasting time and money.</span>\r\n\r\n&nbsp;\r\n<h3>CONTACT POINT:</h3>\r\n<span style=\"font-weight: 400;\"><img class=\"alignnone wp-image-10194\" src=\"http://mediainnovation.news/wp-content/uploads/2016/06/Miyuki-Inoue-300x199.jpg\" alt=\"Miyuki Inoue\" width=\"207\" height=\"137\" /></span>\r\n\r\n<span style=\"font-weight: 400;\">Miyuki </span><span style=\"font-weight: 400;\">Inoue,\u00a0</span><span style=\"font-weight: 400;\">Business Developer / Researcher / Writer</span>\r\n\r\n<span style=\"font-weight: 400;\">Twitter: <a href=\"https://twitter.com/MyuInoue\">@MyuInoue\r\n</a></span><span style=\"font-weight: 400;\"><a href=\"https://medium.com/me/stories/public\">Medium</a>\u00a0</span><a href=\"https://medium.com/me/stories/public\"><span style=\"font-weight: 400;\">\r\n</span></a><a href=\"https://www.linkedin.com/in/\u672a\u96ea-\u4e95\u4e0a-06452468?trk=hp-identity-name\"><span style=\"font-weight: 400;\">LinkedIn</span></a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Asahi Shimbun Media Lab: internal innovation","post_link":"https://media-innovation.news/media-lab/10193-2/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Asahi Shimbun Media Lab: internal innovation\" width=\"300\" height=\"225\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Asahi-Media-Lab-Takeshita-Miyuki-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"brainstorming, internal innovation, Japan, newspaper","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1517439313:1","%_edit_last%":"1","%_thumbnail_id%":"10195","%_item_likes%":"0","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_kleo_title_checkbox%":"1","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_content_score%":"30","%_wpgmp_location_address%":"\u65e5\u672c\u6771\u4eac\u90fd\u4e2d\u592e\u533a\u7bc9\u5730\uff15\u4e01\u76ee\uff13\u2212\uff12 Asahi Shimbun Media Production \u682a\u5f0f\u4f1a\u793e \u671d\u65e5\u65b0\u805e\u30e1\u30c7\u30a3\u30a2\u30d7\u30ed\u30c0\u30af\u30b7\u30e7\u30f3","%_wpgmp_metabox_latitude%":"35.6639309","%_wpgmp_metabox_longitude%":"139.76562009999998","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545361786,"payload":[{"id":11235},{"id":10754},{"id":11494}]}},"taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"brainstorming, internal innovation, Japan, newspaper"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10193,"infowindow_disable":false},{"source":"post","title":"Sud Ouest\u2019s Th\u00e9ophraste: in-house acceleration and collaborative enterprise","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sud Ouest\u2019s Th\u00e9ophraste: in-house acceleration and collaborative enterprise\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Theophraste-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Sud Ouest\u2019s Th\u00e9ophraste: in-house acceleration and collaborative enterprise</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Bordeaux\u2019s Sud Ouest newspaper' startup lab \u2013 Th\u00e9ophraste \u2013 invites local startups to share office space and resources to help accelerate their development.  \r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/sud-ouests-theophraste-in-house-acceleration-and-collaborative-enterprise/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Bordeaux\u2019s Sud Ouest newspaper' startup lab \u2013 Th\u00e9ophraste \u2013 invites local startups to share office space and resources to help accelerate their development.  ","address":"Sud Ouest Publicit\u00e9, Quai des Queyries, Bordeaux, France","location":{"lat":"44.84323699999999","lng":"-0.5639599999999518","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/sud-ouests-theophraste-in-house-acceleration-and-collaborative-enterprise/","zoom":2,"extra_fields":{"post_excerpt":"Bordeaux\u2019s Sud Ouest newspaper' startup lab \u2013 Th\u00e9ophraste \u2013 invites local startups to share office space and resources to help accelerate their development.  ","post_content":"[vc_row][vc_column width=\"1/6\"][vc_column_text letter_spacing=\"\"][/vc_column_text][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]\r\n<h1>Sud Ouest\u2019s Th\u00e9ophraste: in-house acceleration and collaborative enterprise</h1>\r\n<span style=\"font-weight: 400;\">With a print circulation of 300,000, Bordeaux\u2019s Sud Ouest newspaper is the second largest regional print offering in France. Its startup lab -</span><a href=\"http://theophraste.io/\"> <span style=\"font-weight: 400;\">Th\u00e9ophraste</span></a><span style=\"font-weight: 400;\"> - is exploring a novel model for innovation: inviting new local startups to share office space and resources from within the organisation to help accelerate their development. \u00a0</span>\r\n<h3><strong>Beliefs and motivations:</strong></h3>\r\n<span style=\"font-weight: 400;\">Sud Ouest believes that although innovation can successfully emanate from inside the company, innovation from an external source can sometimes be even more effective due to the diversity it naturally creates. Startups, for example, have their own vision, methodologies and workflows. By reaching out to the local startup scene, Sud Ouest hopes to prompt new products and ways of working via a \u201cshock of cultures\u201d.</span>\r\n<blockquote><i><span style=\"font-weight: 400;\">\u201cConfronting staff expertise, competences, methodologies to the startups and their own vision and approaches was bound to have positive consequences and create a win-win situation for everyone\u201d said Guillaume Vasse, Head of Digital Development and Head of Marketing (CDO and CMO) at Groupe Sud Ouest.</span></i></blockquote>\r\n<span style=\"font-weight: 400;\">Established during the first part of 2016,</span><a href=\"http://theophraste.io/\"> <span style=\"font-weight: 400;\">Th\u00e9ophraste</span></a><span style=\"font-weight: 400;\"> - named after Th\u00e9ophraste Renaudot founder of one of the oldest 17th century French newspapers - houses startups for between 6 to 12 months. Its aim is to support and accelerate business development and foster collaboration between the company and the startups.</span>\r\n<h3><b>Methodology:</b></h3>\r\n<span style=\"font-weight: 400;\">The implementation of the project took place in two stages. The first was to partner with a regional startup incubator based in Lyon and Bordeaux called</span><a href=\"https://1kubator.com/\"> <span style=\"font-weight: 400;\">1Kubator</span></a><span style=\"font-weight: 400;\">. Sud Ouest agreed to host</span><a href=\"https://1kubator.com/\"> <span style=\"font-weight: 400;\">1Kubator</span></a><span style=\"font-weight: 400;\"> and their startups in their offices free of charge. In exchange the startup experts would help the team at Sud Ouest understand the startup environment and assist them in creating their own startup accelerator.</span>\r\n<blockquote><i><span style=\"font-weight: 400;\">\u201cThis first period was a success as curiosity started taking over very early on with staff inquiring about the 1Kubator startups before even starting the Th\u00e9ophraste programme,\u201d says Vasse.</span></i></blockquote>\r\n<span style=\"font-weight: 400;\">The second step was to create Sud Ouest\u2019s own acceleration programme.</span> <span style=\"font-weight: 400;\">The concept is to lend office space to a handful of startups selected after a call for application launched mid May this year.</span>\r\n\r\n<span style=\"font-weight: 400;\">Although they don\u2019t have a preconceived idea of what types of startups they are looking for to be selected the startup should:</span>\r\n<ul>\r\n \t<li><span style=\"font-weight: 400;\">\u00a0\u00a0\u00a0\u00a0\u00a0</span><span style=\"font-weight: 400;\">Have already obtained legal entity</span></li>\r\n \t<li><span style=\"font-weight: 400;\">\u00a0\u00a0\u00a0\u00a0\u00a0</span><span style=\"font-weight: 400;\">Already have a proof of concept</span></li>\r\n \t<li><span style=\"font-weight: 400;\">\u00a0\u00a0\u00a0\u00a0\u00a0</span><span style=\"font-weight: 400;\">Could be Media or non media related</span></li>\r\n</ul>\r\n<span style=\"font-weight: 400;\">The jury, consisting both of Sud Ouest staff and of the 1Kubator team will also take into account individual competencies, group dynamic, but also the originality of the project and the willingness of each team.</span>\r\n\r\n<span style=\"font-weight: 400;\">The selected startups will then benefit:</span>\r\n<ul>\r\n \t<li><span style=\"font-weight: 400;\">6 to 12-month acceleration period (flexible period as it will depend on how successful the acceleration is)</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Access to mentors (from Sud Ouest, 1Kubator but also external: legal team, other industries etc.)</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Access to the publisher\u2019s network and competencies (advertising, content and services, logistics etc.)</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Testing environment in a real-life media company (data, beta testers)</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Connection to regional, national and international innovation networks (Bordeaux French Tech, WAN-IFRA\u2019s GAMI network)</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Help with fundraising</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Possibility for the Media company to invest through \u201cmedia for equity\u201d (ad space for free)</span></li>\r\n</ul>\r\n<h3><b>\u201cA win-win situation\u201d</b></h3>\r\n<i><span style=\"font-weight: 400;\">\u201cWe don\u2019t want to work with our startups like we would work with a subcontractor\u201d</span></i><span style=\"font-weight: 400;\"> underlines Guillaume Vasse.</span>\r\n\r\n<span style=\"font-weight: 400;\">Indeed, it is a very clear philosophy at Sud Ouest that the objective is to infuse innovation in the company by experimentation and collaboration - and not just to look for another client-to-contractor relationship.</span>\r\n\r\n<span style=\"font-weight: 400;\">Startups will have the opportunity to work with and be assisted by a large media group. This provides them with access to a range of skills including communication, user experience, production and digital, Vasse suggests. The interest for Sud Ouest is to learn different ways of thinking and working especially compared to those of a large corporation.</span>\r\n\r\n<span style=\"font-weight: 400;\">It seems important to keep in mind that it should always remain a win-win situation for the startup and for the company.</span>\r\n<h3><b>Resources</b></h3>\r\n<span style=\"font-weight: 400;\">The team running Th\u00e9opraste consists of Guillaume Vasse and the three staff from 1Kubator. Vasse suggests that the financial investment needed was very limited: office space, desks, chairs, time and a new coffee machine. These limited resources make the necessary buy-in from top management easier to obtain.</span>\r\n\r\n<span style=\"font-weight: 400;\">There\u2019s also opportunities for Sud Ouest staff, who have been given the option of taking a sabbatical leave to start a company hosted by the accelerator.</span>\r\n<h3><b>Keys to success?</b></h3>\r\n<span style=\"font-weight: 400;\">The future success of Th\u00e9opraste may lie in the pre-established company culture at Sud Ouest \u2013 it has supported the local innovation startup scene for years before starting this initiative (reporting about tech innovation and startups, participation in startup weekends). Sud Ouest believes that earned legitimacy is important for credibility. Vasse advises: </span><i><span style=\"font-weight: 400;\">\u201cDon\u2019t reach out to startups just because it\u2019s the done thing at the moment\u201d.</span></i>\r\n\r\n<span style=\"font-weight: 400;\">At the same time a startup only looking for free square meters is wasting everyone\u2019s time: \u201c</span><i><span style=\"font-weight: 400;\">we are looking for a two-way collaboration and an exchange of know-how.\u201d</span></i>\r\n\r\n<span style=\"font-weight: 400;\">Another challenge could be the cohabitation between staff and \u201cstart-uppers\u201d. Vasse recommends that staff should not feel left aside and that startups and staff were treated the same way.</span>\r\n<blockquote><i><span style=\"font-weight: 400;\">\u201cThis is also one of the reasons why it is a primary importance that Th\u00e9ophraste takes place inside the newspaper building as it creates de facto an obligatory meet-up with the rest of the staff.\u201d</span></i></blockquote>\r\n<h3 class=\"p1\">Next ?</h3>\r\n<p class=\"p1\"><span class=\"s1\">They are actively preparing an offer of 'media for equity' for the startups.\u00a0Media for equity is literally exchanging advertising space against a part of the startup's capital.\u00a0For them, the\u00a0interest is to build a sustainable partnership with a startup that they consider promising and with whom they wish to engage more strongly than through\u00a0a simple commercial contract. For the startup it's simply a convenient way to gain useful visibility\u00a0during the\u00a0period of acceleration.</span></p>\r\n\r\n<h3></h3>\r\n<h3>CONTACT POINT:</h3>\r\n<img class=\" wp-image-10102\" src=\"http://mediainnovation.news/wp-content/uploads/2016/06/photogvasse2-200x300.jpg\" alt=\"Bordeaux 13 Mai 2011 SUD OUEST Portrait Guillaume VASSE Directeur du D\u00e9veloppement num\u00e9rique et Marketing - David Thierry ( SUD OUEST )\" width=\"151\" height=\"227\" />\r\n\r\n<span style=\"font-weight: 400;\">Guillaume Vasse,\u00a0</span><span style=\"font-weight: 400;\">CDO &amp; CMO,\u00a0Groupe Sud Ouest, France\r\n</span><span style=\"font-weight: 400;\">guillaume.vasse @ gsoi.fr\r\n</span><a href=\"https://twitter.com/gvasse\"><span style=\"font-weight: 400;\">@gvasse</span></a>\r\n\r\nMedia Lab: Theophraste\r\n\r\n<span style=\"font-weight: 400;\">twitter : </span><a href=\"https://twitter.com/Theophrasteio\"><span style=\"font-weight: 400;\">@Theophrasteio\r\n</span></a><span style=\"font-weight: 400;\">web : </span><a href=\"http://theophraste.io/\"><span style=\"font-weight: 400;\">http://theophraste.io/</span></a>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>","post_title":"Sud Ouest\u2019s Th\u00e9ophraste: in-house acceleration and collaborative enterprise","post_link":"https://media-innovation.news/media-lab/sud-ouests-theophraste-in-house-acceleration-and-collaborative-enterprise/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sud Ouest\u2019s Th\u00e9ophraste: in-house acceleration and collaborative enterprise\" width=\"300\" height=\"169\" src=\"https://media-innovation.news/wp-content/uploads/2016/06/Theophraste-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs","post_tags":"accelerator, France, incubator, newspaper, startups","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1517439192:1","%_edit_last%":"1","%slide_template%":"default","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_item_likes%":"0","%_wpb_vc_js_status%":"true","%_thumbnail_id%":"10109","%_kleo_title_checkbox%":"1","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_content_score%":"30","%_wpgmp_location_address%":"Sud Ouest Publicit\u00e9, Quai des Queyries, Bordeaux, France","%_wpgmp_metabox_latitude%":"44.84323699999999","%_wpgmp_metabox_longitude%":"-0.5639599999999518","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545352053,"payload":[{"id":10991},{"id":11494},{"id":10201}]}},"taxonomy=category":"Innovation Case, Media labs","taxonomy=post_tag":"accelerator, France, incubator, newspaper, startups"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":10101,"infowindow_disable":false},{"source":"post","title":"Open Lab","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Open Lab\" width=\"300\" height=\"225\" src=\"https://media-innovation.news/wp-content/uploads/2016/05/Open-Lab-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs, Research projects</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Open Lab</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            A cross disciplinary approach to digital technology driven by users and participatory innovation.\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/open-lab/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"A cross disciplinary approach to digital technology driven by users and participatory innovation.","address":"Newcastle University, Newcastle upon Tyne, United Kingdom","location":{"lat":"54.9791871","lng":"-1.6146608000000242","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/open-lab/","zoom":2,"extra_fields":{"post_excerpt":"A cross disciplinary approach to digital technology driven by users and participatory innovation.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]\r\n<h1><b>Open Lab</b></h1>\r\nBased at Newcastle University\u2019s School of Computing Science, Open Lab first began in 2008 as the \u2018digital interaction\u2019 group inside Culture Lab. Led by Professor Patrick Olivier, it\u2019s remit is to explore cross disciplinary research in digital technologies, and particularly in the fields if the digital economy, user-centred health and social care. It is now the home of over 160 researchers that include human-computer interaction specialists, product designers, electrical engineers, fine artists, psychologists and sociologists.\r\n\r\n&nbsp;\r\n<h3><b>Approaches to innovation </b></h3>\r\n<span style=\"font-weight: 400;\">Participatory design and user driven innovation are key approaches at Open Lab, and runs inside research that explores a more technical agenda. Increasingly, projects are exploring commissioning and civic engagement, and put the user and the crowd at the centre of any product or service that emerges.</span>\r\n\r\n<span style=\"font-weight: 400;\">Using the example of Bootlegger - crowd-sourced and crowd-generated video platform that allows users to create a filmic version of an event through combining multiple streams of footage, Professor Patrick Olivier explains: \u201cWe\u2019re thinking about platforms that make it easy to commission content from citizens. Users can commission it from each other - create short video clips with meta data on the shot, they can edit it together easily on the mobile and the app.\u201d</span>\r\n\r\n<img class=\"alignnone wp-image-10180 size-large\" src=\"http://mediainnovation.news/wp-content/uploads/2016/05/app-movement-1024x372.png\" alt=\"app movement\" width=\"1024\" height=\"372\" />The <a href=\"https://app-movement.com/\">App-movement platform</a> follows in a similar vein.\r\n<blockquote><span style=\"font-weight: 400;\">\u201cIt\u2019s a similar idea. If you want a trip adviser-like app - a location based review system - you can go here and propose one. People support it online, and if you get enough support through voting, the app is automatically generated. There\u2019s no specific developer [as the infrastructure is already there], it just gets generated and appears in the app store.\u201d</span></blockquote>\r\nOpen Lab\u2019s approach contains two final elements. The first is that all outputs are open source, and therefore freely available to the world-wide community, and all work is designed can be scaled, rather than limited to small numbers or products or individual prototypes.\r\n\r\n&nbsp;\r\n<h3><b>Industry collaborations, and scope for innovation </b></h3>\r\n<span style=\"font-weight: 400;\">Research at the Lab spans a number of local and national organisations. From a news media perspective, it has links with local and national publishers. It also has a user engagement partnership with the BBC. As such, it can collaborate on a number of levels - which include specific projects, internships and PhDs. This raises interesting opportunities and challenges from an innovation perspective. </span>\r\n<blockquote><span style=\"font-weight: 400;\">Professor Olivier explains: \u201cWhen we work with the BBC, we work with their R&amp;D teams and there\u2019s a huge gulf between them and the actual journalists. Sometimes we have students go and do internships and they\u2019ve done interviews with journalists about where they\u2019ve found their stories and the real people they speak with, but in most instances there\u2019s quite a big disconnect between research and the actual producers and creatives.\u201d</span></blockquote>\r\n<blockquote><span style=\"font-weight: 400;\">\u201cThis is a negative thing, and the BBC are constantly thinking about how they can create real content channels\u2026 the clash between innovation, research and actual content production is the issue around quality. The anxiety they would have about experimenting and the resulting editorial quality they would want.\"</span></blockquote>\r\nLooking at potential solutions to this anxiety, Olivier suggests that media provides need \u201cchannels that are more experimental that you could try some of these more innovative approaches through - that\u2019s a key thing newspapers could consider.\r\n<blockquote><span style=\"font-weight: 400;\">\u201cLocal newspapers could be the key places to do this experimentation. What you need are side channels for these organisations that could be experimental. But you do want that channel out to the public, even if it\u2019s experimental. \u201c</span></blockquote>\r\n&nbsp;\r\n<h3><b>Funding</b></h3>\r\n<span style=\"font-weight: 400;\">Funded by all the UK research councils ranging from Arts and Humanities to Biotechnology and Biological Sciences, the current active fund stands at \u00a310.3 million. In addition to the research councils, Open Lab works with companies and charities to fund PhD studentships. Olivier also suggests that European funding is also in the pipeline. </span>\r\n\r\nThe centre for doctoral training also receives match funding, but rather than direct monetary investment, \u00a0this support generally takes the form of access to time or resource of the specific partners.\r\n\r\n&nbsp;\r\n<h3><b>Challenges to industry collaboration </b></h3>\r\n<span style=\"font-weight: 400;\">Olivier suggests that a main challenge to industry collaboration is intellectual property and where it resides. This is becoming less of an obstacle for Open Lab as much of the output is now open source. </span>\r\n\r\nA further challenge is that how the research divisions and the product division, particularly within large organisations, are a long way apart. \u201cWe tend to be collaborating with other researchers rather than those doing the content delivery or products.\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\nProfessor Patrick Olivier\r\n\r\n<img class=\"irc_mi\" src=\"https://digitalcivics.io/wp-content/uploads/2016/10/Patrick.jpeg\" alt=\"Image result for Professor Patrick Olivier\" width=\"391\" height=\"587\" />\r\n\r\nweb:\u00a0<a href=\"https://openlab.ncl.ac.uk/\">openlab.ncl.ac.uk</a>\r\n\r\ntwitter: @patricklolivier[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Open Lab","post_link":"https://media-innovation.news/media-lab/open-lab/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Open Lab\" width=\"300\" height=\"225\" src=\"https://media-innovation.news/wp-content/uploads/2016/05/Open-Lab-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs, Research projects","post_tags":"community commissioning, Immersive, industry collaboration, open innovation, open source, UK","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1517439309:1","%_edit_last%":"1","%_item_likes%":"0","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_kleo_site_style%":"boxed","%_oembed_f8deede0e7ca5c7a4028301c7ffc593e%":"{{unknown}}","%_thumbnail_id%":"10181","%_kleo_title_checkbox%":"1","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"","%_wpgmp_location_address%":"Newcastle University, Newcastle upon Tyne, United Kingdom","%_wpgmp_metabox_latitude%":"54.9791871","%_wpgmp_metabox_longitude%":"-1.6146608000000242","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545285506,"payload":[{"id":10130},{"id":10144},{"id":10776}]}},"taxonomy=category":"Innovation Case, Media labs, Research projects","taxonomy=post_tag":"community commissioning, Immersive, industry collaboration, open innovation, open source, UK"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":9945,"infowindow_disable":false},{"source":"post","title":"Centre for Community Journalism: engaging and innovating","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Centre for Community Journalism: engaging and innovating\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2016/05/C4CJ-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs, Research projects</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Centre for Community Journalism: engaging and innovating</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            C4CJ offers one-to-one support, hyperlocal journalism hubs and massive open online courses with global reach and thousands of participants\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/centre-for-community-journalism/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"C4CJ offers one-to-one support, hyperlocal journalism hubs and massive open online courses with global reach and thousands of participants","address":"Cardiff University, Cardiff, United Kingdom","location":{"lat":"51.4866271","lng":"-3.1788641000000553","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/centre-for-community-journalism/","zoom":2,"extra_fields":{"post_excerpt":"C4CJ offers one-to-one support, hyperlocal journalism hubs and massive open online courses with global reach and thousands of participants","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]\r\n<h1><span style=\"font-weight: 400;\">Centre for Community Journalism: engaging and innovating</span></h1>\r\n<span style=\"font-weight: 400;\">One-to-one support, hyperlocal journalism hubs and massive open online courses with global reach and thousands of participants, Cardiff\u2019s Centre For Community Journalism\u2019s (C4CJ) mission is to strengthen journalism from the ground up. Through encouraging the public and supporting hyperlocal publishers, it offers training, resources and networking, and has received five-years of funding from Cardiff University to enable it to continue its work throughout Wales and beyond. \u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Although not strictly a development lab, it offers a range of opportunities for industry collaboration and digital development, and has strong links with the BBC and hyperlocal networks. </span>\r\n\r\n&nbsp;\r\n<h3><b>Reach and connected communities </b></h3>\r\n<span style=\"font-weight: 400;\">C4CJ has a small core staff of two people - but its reach and engagement with a range of communities, local and national media and citizen journalists across the globe is impressive. </span>\r\n\r\nWith estimated engagement figures of over 32,000, the centre\u2019s MOOC (massive open online course) on the futurelearn platform extends hyperlocal and citizen journalism support beyond the communities and ten hubs in Wales, and creates an opportunity for a global audience spanning 140 countries to connect with C4CJ\u2019s support.\r\n\r\nBut the approach is an open one, and the centre is dedicated to responding to its users\u2019 needs, rather than any pre-determined approach.\r\n\r\n<span style=\"font-weight: 400;\">Emma Meese, the Centre\u2019s manager, said: \u201cWe put the information out there and ask - what do you think? And we start the conversation. It\u2019s about listening and engaging - everything we do is about engaging with communities, listening to them and assessing the community\u2019s needs. We then offer help and advice.\u201d </span>\r\n\r\n&nbsp;\r\n<h3><b>Methods and innovation </b></h3>\r\n<span style=\"font-weight: 400;\">Meese highlights that the centre\u2019s approach is flexible, and responds to the specific environments and challenges. </span>\r\n\r\n<span style=\"font-weight: 400;\">\u201cWe take innovative methods and approaches, and create new tools. If we find patterns of behaviour or activity that demonstrate a problem, we try to find a way of solving that problem for them.\u201d</span>\r\n\r\nA response that has emerged from this approach include the Storini platform and Newstori app, which was co-designed with REACT at the Pervasive Media Studio and allows users to publish and share stories. The app also allows users to send content to a range of hyperlocal publishers based on the geolocation of the story the citizen journalist is cover.\r\n\r\n<span style=\"font-weight: 400;\">A second project saw the centre receive funding from the Welsh government to create a dedicated citizen journalism Wordpress theme to combat barriers to entry for start-up community journalism initiatives. </span>\r\n\r\n<span style=\"font-weight: 400;\">The centre is also involving in hacking hyperlocal activities - and plans to hold Hack-the-local event in the summer. Meese also highlighted that all of the work is based around real-world impact, and includes long-term engagement, start-up support </span>\r\n\r\n&nbsp;\r\n<h3><b>Industry collaborations </b></h3>\r\n<span style=\"font-weight: 400;\">The centre has a track record of collaborating with a range of news media publishers around training and hyperlocal development. Meese sits on the BBC\u2019s local journalism working group, which seeks to establish ways that the industry figures can support and work with hyperlocal content providers, and assists in identifying opportunities that larger publishers can amplify community news. </span>\r\n\r\n<span style=\"font-weight: 400;\">\r\n</span><span style=\"font-weight: 400;\">As part of this general approach, the centre works established media organisations such a the Press Association, Trinity Mirror and Johnston Press. </span>\r\n\r\n<span style=\"font-weight: 400;\">It collaborates with non-media organisations that have a vested interest in supporting journalism. These include the UK\u2019s National Endowment for Science and the Arts (Nesta) and the Welsh Assembly. </span>\r\n\r\n&nbsp;\r\n<h3><b>Future plans</b></h3>\r\n<span style=\"font-weight: 400;\">The centre has a number of specific plans in the coming months and years. They will continue to support community and citizen journalists through training, support and innovative methods. Some of the plans include setting up a representative body for community news working with communities of interest as well as geographic communities , and exploring other hyperlocal news portals such as schools and from with government structures. </span>\r\n\r\n&nbsp;\r\n\r\nCONTACT POINT\r\n\r\n<img class=\"alignnone\" src=\"http://www.s4c.cymru/creadigidol/img/emma-meese-large.jpg\" width=\"1140\" height=\"362\" />\r\n\r\nEmma Meese, centre manager\r\n\r\nWeb:\u00a0<a href=\"https://www.communityjournalism.co.uk/en/\">communityjournalism.co.uk/en/</a>\r\n\r\nTwitter:\u00a0<a href=\"https://twitter.com/EmmaMeese\">@EmmaMeese</a>\r\n\r\n<span style=\"font-weight: 400;\">\f</span>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]\r\n\r\n<span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span><span style=\"border-top-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-bottom-left-radius: 2px; text-indent: 20px; width: auto; padding: 0px 4px 0px 0px; text-align: center; font-style: normal; font-variant-caps: normal; font-weight: bold; font-stretch: normal; font-size: 11px; line-height: 20px; font-family: 'Helvetica Neue', Helvetica, sans-serif; color: #ffffff; background-image: url(data:image/svg+xml; base64,phn2zyb4bwxucz0iahr0cdovl3d3dy53my5vcmcvmjawmc9zdmciighlawdodd0imzbwecigd2lkdgg9ijmwchgiihzpzxdcb3g9ii0xic0xidmxidmxij48zz48cgf0acbkpsjnmjkundq5lde0ljy2mibdmjkundq5ldiyljcymiaymi44njgsmjkumju2ide0ljc1ldi5lji1nibdni42mzismjkumju2idaumduxldiyljcymiawlja1mswxnc42njigqzaumduxldyunjaxidyunjmyldaumdy3ide0ljc1ldaumdy3iemymi44njgsmc4wnjcgmjkundq5ldyunjaxidi5ljq0oswxnc42njiiigzpbgw9iinmzmyiihn0cm9rzt0ii2zmziigc3ryb2tllxdpzhropsixij48l3bhdgg+phbhdgggzd0itte0ljczmywxljy4nibdny41mtysms42odygms42njusny40otugms42njusmtqunjyyiemxljy2nswymc4xntkgns4xmdksmjquodu0idkuotcsmjyunzq0iem5ljg1niwyns43mtggos43ntmsmjqumtqzidewljaxniwymy4wmjigqzewlji1mywymi4wmsaxms41ndgsmtyuntcyidexlju0ocwxni41nzigqzexlju0ocwxni41nzigmteumtu3lde1ljc5nsaxms4xntcsmtqunjq2iemxms4xntcsmtiuodqyideyljixmswxms40otugmtmuntiyldexljq5nsbdmtqunjm3ldexljq5nsaxns4xnzusmtiumzi2ide1lje3nswxmy4zmjmgqze1lje3nswxnc40mzygmtqundyylde2ljegmtqumdkzlde3ljy0mybdmtmunzg1lde4ljkznsaxnc43ndusmtkuotg4ide2ljayocwxos45odggqze4ljm1mswxos45odggmjaumtm2lde3lju1niaymc4xmzysmtqumdq2iemymc4xmzysmtauotm5ide3ljg4ocw4ljc2nyaxnc42nzgsoc43njcgqzewljk1osw4ljc2nya4ljc3nywxms41mzygoc43nzcsmtqumzk4iem4ljc3nywxns41mtmgos4ymswxni43mdkgos43ndksmtcumzu5iem5ljg1niwxny40odggos44nzismtcunia5ljg0lde3ljczmsbdos43ndesmtgumtqxidkuntismtkumdizidkundc3lde5ljiwmybdos40miwxos40nca5lji4ocwxos40otegos4wncwxos4znzygqzcunda4lde4ljyymia2ljm4nywxni4yntigni4zodcsmtqumzq5iem2ljm4nywxmc4yntygos4zodmsni40otcgmtuumdiyldyundk3iemxos41ntusni40otcgmjmumdc4ldkunza1idizlja3ocwxmy45otegqzizlja3ocwxoc40njmgmjaumjm5ldiylja2miaxni4yotcsmjiumdyyiemxnc45nzmsmjiumdyyidezljcyocwyms4znzkgmtmumzayldiwlju3mibdmtmumzayldiwlju3miaxmi42ndcsmjmumdugmtiundg4ldizljy1nybdmtiumtkzldi0ljc4ncaxms4zotysmjyumtk2idewljg2mywyny4wntggqzeylja4niwyny40mzqgmtmumzg2ldi3ljyznyaxnc43mzmsmjcunjm3iemyms45nswyny42mzcgmjcuodaxldixljgyocayny44mdesmtqunjyyiemyny44mdesny40otugmjeuotusms42odygmtqunzmzldeunjg2iibmawxspsijymqwodfjij48l3bhdgg+pc9npjwvc3znpg==); background-size: 14px 14px; background-color: #bd081c; position: absolute; opacity: 1; z-index: 8675309; display: none; cursor: pointer; border: none; -webkit-font-smoothing: antialiased; background-position: 3px 50%; background-repeat: no-repeat no-repeat;\">Save</span>","post_title":"Centre for Community Journalism: engaging and innovating","post_link":"https://media-innovation.news/media-lab/centre-for-community-journalism/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Centre for Community Journalism: engaging and innovating\" width=\"300\" height=\"200\" src=\"https://media-innovation.news/wp-content/uploads/2016/05/C4CJ-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs, Research projects","post_tags":"citizen journalism, community journalism, hacks, Immersive, MOOC, training and education, UK","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1517439806:1","%_edit_last%":"1","%_item_likes%":"0","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_oembed_900030fd7e0347d6d5e6a107a099083c%":"{{unknown}}","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"10215","%_wp_old_slug%":"c4cj","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_content_score%":"30","%_wpgmp_location_address%":"Cardiff University, Cardiff, United Kingdom","%_wpgmp_metabox_latitude%":"51.4866271","%_wpgmp_metabox_longitude%":"-3.1788641000000553","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545331234,"payload":[{"id":11024},{"id":10776},{"id":9934}]}},"taxonomy=category":"Innovation Case, Media labs, Research projects","taxonomy=post_tag":"citizen journalism, community journalism, hacks, Immersive, MOOC, training and education, UK"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":9941,"infowindow_disable":false},{"source":"post","title":"Pervasive Media Studio","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pervasive Media Studio\" width=\"300\" height=\"90\" src=\"https://media-innovation.news/wp-content/uploads/2016/05/Pervasive-Media-Studio-300x90.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n    <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">Innovation Case, Media labs, Research projects</div>\r\n        <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Pervasive Media Studio</div>\r\n        <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n            Creating innovation through a multidisciplinary collaboration, \r\n\r\n        </div>\r\n<a href=\"https://media-innovation.news/media-lab/pervasive-media-studio/\">Read more</a>\r\n    </div>\r\n    </div>\r\n</div>\r\n\r\n","content":"Creating innovation through a multidisciplinary collaboration, \r\n","address":"Pervasive Media Studio, Bristol, United Kingdom","location":{"lat":"51.4508786","lng":"-2.5991750000000593","onclick_action":"post","redirect_permalink":"https://media-innovation.news/media-lab/pervasive-media-studio/","zoom":2,"extra_fields":{"post_excerpt":"Creating innovation through a multidisciplinary collaboration, \r\n","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_column_text letter_spacing=\"\"]\r\n<h1><strong>Pervasive Media Studio</strong></h1>\r\n<span style=\"font-weight: 400;\">Located at the centre of Bristol, the Pervasive Media Studio is a 100-person strong community of creative digital innovators engaging in multidisciplinary research and development. Spanning artists, technologists, makers, product designers and storytellers, the Studio hosts a range of projects that, in the words of Studio producer Victoria Tillson, \u201clook beyond what exists at the moment\u201d and helps to \u201cbreak research out of universities\u201d. \u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">The Studio is a joint project between the University of the West of England, University of Bristol and Watershed, a social enterprise combining cinema, cafe/bar and event space. It\u2019s interdisciplinary approach to \u2018pervasive media\u2019 creates a wide and diverse project base that span citizen-led interplanetary space exploration, playable cities, digital-physical experiences and independent and immersive documentary making. The Studio\u2019s projects span a number of broad areas that include: context aware experiences, media in public spaces, UCG, mobile gaming and performance. These areas interface with local and international communities, commercial and other organisations, and seek to explore research and digital interaction development opportunities that are firmly located in the real world. It\u2019s philosophy is one of open, interdisciplinary and community-led innovation.\u00a0</span>\r\n<h3><b>Methods and approaches\u00a0</b></h3>\r\nOpenness and collaboration permeate the Pervasive Media Studio. Rather than a research centre that employs paid staff, many of the studio\u2019s residents are not directly employed by the centre, and instead are offered a free desk and access to facilities as a result of their work and ideas.\r\n<blockquote><em><strong>\u201cWe have an open rolling invitation on our website where people can get in touch and apply to be here with an idea they have.. Other people may end up here through another programme we run as we support people to develop new or risky ideas that people don\u2019t necessarily know are going to work but need some time and space to be able to test things out and bounce ideas of people in the Studio.\u201d \u00a0</strong></em></blockquote>\r\n<span style=\"font-weight: 400;\">The relationship with the studio as a whole is based around \u2018interruptibility\u2019 and sharing. Residents can be asked to chat about their work at any point to other residents or whoever may be visiting.\u201d</span>\r\n\r\n<span style=\"font-weight: 400;\">Located in the city centre and Watershed\u2019s cafe bar and cinemas, residents are continually engaged with the community and underpinned by a \u2018gift economy\u2019, which incorporates both residencies within the Studio, and how the Studio itself engages with the wider community.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Most \u2018residents\u2019 do not pay for desk or are employed directly by the Studio - and can work on current or develop new projects. Instead, they are invited to take a space. From there, they receive support of Studio Producers to develop projects and realise ideas. Members of studio include individuals, academics, SMEs and commercial organisations.\u00a0</span>\r\n<h3><b>Industry collaboration\u00a0</b><span style=\"font-weight: 400;\">\u00a0</span></h3>\r\n<span style=\"font-weight: 400;\">From a news media perspective, the Pervasive Media Studio has close links with the BBC, which is based right on their doorstep in Bristol, which hosts a number of operations, including the broadcaster\u2019s Natural History Unit. However, the dynamic of this relationship follows the centre\u2019s overarching approach: the BBC are one member of a community.</span>\r\n\r\n<span style=\"font-weight: 400;\">Individuals within the studio also have their own connections, and, with a culture of prototyping and product development, new commercial organisations emerge from the R&amp;D work.</span>\r\n<h3><b>Key projects</b></h3>\r\n<span style=\"font-weight: 400;\">Although the Pervasive Media Studio has few links with newsdesks or newsrooms, from a news media perspective, there are a number of projects that could be of interest to news media publishers\u00a0</span>\r\n<p style=\"text-align: center;\"><iframe src=\"https://www.youtube.com/embed/fbIci0Bb51o\" width=\"640\" height=\"360\" frameborder=\"0\" allowfullscreen=\"allowfullscreen\"></iframe></p>\r\n<i>Quipu</i><span style=\"font-weight: 400;\">: A \u2018transmedia\u2019 project and interactive documentary that told the story of 272,000 Peruvian women who had been sterilised as part of government policy, sometimes forcibly or without full consent. Quipu provides a framework for these stories to be revealed through radio, interactive digital documentary and a specially developed telephone line that provides a link with women in often remote and rural areas.\u00a0</span>\r\n\r\n<i>Newstori</i><span style=\"font-weight: 400;\">: Coming out of the REACT Hub at the Pervasive Media Studio, and a collaboration between the Cardiff School of Journalism and creative agency Behaviour, Newstori explores sustainable platforms for hyperlocal journalism, and motivations for citizen journalists.\u00a0</span>\r\n<p style=\"text-align: center;\"><iframe src=\"https://www.youtube.com/embed/GW6WGlhx37U\" width=\"640\" height=\"360\" frameborder=\"0\" allowfullscreen=\"allowfullscreen\"></iframe></p>\r\n<i>Nth Screen:\u00a0</i><span style=\"font-weight: 400;\">Specialising in video mosaics, Nth Screen allows multiple users to generate and contribute to multi-perspective video montages.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">Beyond the focus of news, other projects point towards innovative digital interactions.\u00a0</span><i>Hello Lamp Post</i><span style=\"font-weight: 400;\">\u00a0uses the physical infrastructure of the city to allow people to communicate and leave messages for one-another, the physical-digital exploration project\u00a0</span><i>Mayfly\u00a0</i><span style=\"font-weight: 400;\">allows users to capture sounds and link them to pages of a physical book and\u00a0</span><i>Pocket Spacecraft\u00a0</i><span style=\"font-weight: 400;\">helps people to launch their very own citizen solar explorer, and monitor its progress with a digital infrastructure.\u00a0</span>\r\n<h3><b>Funding\u00a0</b></h3>\r\n<h3></h3>\r\n<span style=\"font-weight: 400;\">The Pervasive Media Studio is underpinned by funding from the founding organisations: the University of the West of England, University of Bristol and Watershed. However, there are some additional funding streams that the Studio as a host has accessed, alongside myriad of other funds residents have accessed.\u00a0</span>\r\n\r\n<span style=\"font-weight: 400;\">The UK\u2019s Research Councils - both arts-led and engineering-focussed - support the studio in a number of ways, and the recently completed REACT Hub, which was one of four centres in the UK designed to unite researchers with creative business to prototype new concepts and ideas. A four-year project between 2012, the initiative focussed on books and print, future documentary, feasibility, heritage and objects. This network has spawned just short of \u00a35m in additional research and investment funding.</span>\r\n\r\n<span style=\"font-weight: 400;\">Due to the diverse project based, other public funding organisation such as the Arts Council and the range of financial support that is available to SME spin outs. Residents may also have their own funding to the projects they\u2019re working on.\u00a0</span>\r\n<h3><b>Future Challenges\u00a0</b></h3>\r\n<h3></h3>\r\n<span style=\"font-weight: 400;\">Victoria Tillson suggests there are a range of challenges for the Pervasive Media Studio - these span shrinking funding opportunities and maintaining the energy and creativity of the projects that emerge from the studio. She explains that this freshness is essential in meeting the needs of the audience. One solution to this is further develop participatory models of engagement and design.\u00a0</span>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row]","post_title":"Pervasive Media Studio","post_link":"https://media-innovation.news/media-lab/pervasive-media-studio/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pervasive Media Studio\" width=\"300\" height=\"90\" src=\"https://media-innovation.news/wp-content/uploads/2016/05/Pervasive-Media-Studio-300x90.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Innovation Case, Media labs, Research projects","post_tags":"cluster, community-led innovation, context aware experiences, industry collaboration, media in public spaces, mobile gaming, multidisciplinary, open innovation, playable cities, ucg, UK","%_vc_post_settings%":{"vc_grid_id":[]},"%_edit_lock%":"1517438277:1","%_edit_last%":"1","%slide_template%":"default","%_wpb_vc_js_status%":"true","%_kleo_transparent_menu_color%":"white","%_kleo_title_color%":"#","%_kleo_title_bg%":", repeat, inherit, scroll, left top","%_kleo_title_bg_color%":"#","%_expiration-date-status%":"saved","%_item_likes%":"0","%_kleo_title_layout%":"center","%_kleo_hide_breadcrumb%":"1","%_kleo_title_top_padding%":"0","%_kleo_site_style%":"wide","%_kleo_title_checkbox%":"1","%_thumbnail_id%":"10174","%_oembed_c62223c43ba86733172159d1ae685bd4%":"{{unknown}}","%_oembed_f602b68fbb83b423c71df97764b6628a%":"{{unknown}}","%_oembed_bb272d9f6758ab613705a703fc4fdf1e%":"{{unknown}}","%_oembed_9b17eee9f4ed14dc8e22e60dfdfe71b9%":"{{unknown}}","%_oembed_725d283a2a00b8868a188219a1932ac6%":"{{unknown}}","%_oembed_db437daa4c6546c94f8be9a1019d5281%":"{{unknown}}","%_oembed_92ac02bb2651e06bca8d14aa4da9b0b6%":"{{unknown}}","%_oembed_cf3e7f60583c5c586203e7175e989866%":"{{unknown}}","%_wp_old_slug%":"pervasive-media","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_content_score%":"30","%_wpgmp_location_address%":"Pervasive Media Studio, Bristol, United Kingdom","%_wpgmp_metabox_latitude%":"51.4508786","%_wpgmp_metabox_longitude%":"-2.5991750000000593","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%sbg_selected_sidebar%":"0","%sbg_selected_sidebar_replacement%":"0","%_jetpack_related_posts_cache%":{"62393b242c7a561774f8ebff5c1c0565":{"expires":1545276585,"payload":[{"id":10776},{"id":10130},{"id":10693}]}},"taxonomy=category":"Innovation Case, Media labs, Research projects","taxonomy=post_tag":"cluster, community-led innovation, context aware experiences, industry collaboration, media in public spaces, mobile gaming, multidisciplinary, open innovation, playable cities, ucg, UK"},"icon":"https://media-innovation.news/wp-content/uploads/2018/02/marker-1.png"},"id":9934,"infowindow_disable":false}],"styles":"[\r\n    {\r\n        \"featureType\": \"administrative\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"simplified\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative\",\r\n        \"elementType\": \"geometry\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"simplified\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative\",\r\n        \"elementType\": \"geometry.fill\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"simplified\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative\",\r\n        \"elementType\": \"geometry.stroke\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"off\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative\",\r\n        \"elementType\": \"labels.text.fill\",\r\n        \"stylers\": [\r\n            {\r\n                \"color\": \"#444444\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative.country\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"simplified\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative.country\",\r\n        \"elementType\": \"geometry\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"simplified\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative.country\",\r\n        \"elementType\": \"geometry.fill\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative.country\",\r\n        \"elementType\": \"geometry.stroke\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"off\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative.locality\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"simplified\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative.locality\",\r\n        \"elementType\": \"geometry\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative.neighborhood\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"off\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative.land_parcel\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"off\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"landscape\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"color\": \"#f2f2f2\"\r\n            },\r\n            {\r\n                \"visibility\": \"off\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"landscape.natural\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"poi\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"off\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"road\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"saturation\": -100\r\n            },\r\n            {\r\n                \"lightness\": 45\r\n            },\r\n            {\r\n                \"visibility\": \"off\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"road.highway\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"simplified\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"road.arterial\",\r\n        \"elementType\": \"labels.icon\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"off\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"transit\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"off\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"water\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"color\": \"#b2b2b2\"\r\n            },\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    }\r\n]","map_property":{"map_id":"2","debug_mode":false},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"}}
What is WAN-IFRA’s Data Science Expert Group?
WAN-IFRA launched the Data Science Expert Group intending to arm practitioners with insights, feedback, and tools to grow audiences, deepen user engagement, and optimise reader revenues.
Interview – Ouest Médialab: Focus on local innovation key to staying “rooted in reality”
The collaborative media lab based in Nantes, France, works closely with local publishers and innovative players in their region. Direct contact with local players helps the lab stay focused on the real issues that companies in their network deal with.
26-27 JANUARY 2023 – MEDIA LAB DAYS #6 Hamburg
The sixth WAN-IFRA Media Labs Days in Hamburg brought together media labs, academics and start-ups to talk innovation processes, Web3 and AI.
Inholland’s Sustainable Media Lab: imagining socially, environmentally and technically sustainable infrastructure
Inholland’s Sustainable Media Lab is leading the way on imagining socially, environmentally and technically sustainable infrastructure.
Green media briefing: Journalism and the Climate Change Crisis eSummit
Last month, WANIFRA’s ‘green media’ PhD candidate Kirsty Styles joined a panel at the World Editors Forum’s Global eSummit.
GAMI Briefing #4: Media Labs session (17.02.22)
GAMI Briefing #4: Media Labs session (17.02.22) Media labs, innovation networks, accelerators and start-ups from across Europe, the fourth edition of GAMI’s regular online briefings covered a diverse range of innovations and ways to innovate. These included new approaches to broadcast technology, AI-powered podcast experiences, open innovation networks that supported media and data-journalism powered by the internet of things. [...]
FASTlab: Future Arts, Science and Technology Laboratory
Our latest media lab piece comes from Professor Paul Egglestone, Head of School of the Creative Industries in the College of Human and Social Futures at the University of Newcastle, Australia. Egglestone is a founding member of the Global Alliance for Media Innovation and formerly founder of the Media Innovation Studio at the University of Central Lancashire. Here, he describes [...]
Green media briefing: a look back at the World News Media Congress
Hear the University of Oxford’s Meera Selva, Pierre Petillault of Alliance Presse and Schibsted’s Markus Ahlberg tackle ‘green media’.
Green media briefing: a brief history of media and the environment
Ahead of a discussion about what’s next for ‘green media’ at the Virtual World News Media Congress, this briefing takes a look back.
Der Tagesspiegel: interdisciplinary and audience-engaged innovation
Der Tagesspiegel: interdisciplinary and audience-engaged innovation Der Tagesspiegel’s Innovation Lab is a hub for interdisciplinary collaboration - producing projects spanning sensor journalism, data visualisation and interactive, immersive storytelling. Led by Hendrik Lehmann, the Lab emerged from a series of individual data journalism projects, and has expanded to produce a range of storytelling and platforms innovations for Der Tagesspiegel’s newsroom operations. [...]
Future Media Hubs: building a media innovation network in the heart of Europe
An international network of sandboxes, innovation labs and accelerators allows its media organisation members to exchange learnings from their innovation projects and make connections with the startup ecosystem.
Alliance Presse: balancing economic and environmental success in the French press
Alliance Presse has made a four-point commitment to tackle environmental issues – focussed on concerns about advertising.
How can AI help improve newsroom productivity?
The GAMI Briefing #1 looked at how news publishers and journalists are using AI-powered solutions to work more efficiently, what kinds of issues arise when these tools are introduced in the newsroom, and what solutions exist to deal with such challenges.
“Tech and journalism are part of the same thing”: takeaways from the Media4Europe Summit
The event highlighted the need for the news media to work with other industries, but sometimes problems arise as different sectors have their own cultures and processes. How can we encourage and support collaborations across disciplines?
BBC Future Planet: sustainable development in a solutions newsroom
BBC Future Planet is calculating its digital footprint and cutting flying, which has cut costs and increased diversity in the newsroom.
Schibsted: after two centuries of innovation – people and planet are now the lead story
Since a shake-up at the top, Head of Sustainability, Britt Nilsen, is making sure the company is leading on diversity and the environment.
Lenfest Institute: working with the Philly Inquirer as a ‘test kitchen’ for COVID innovation and more
The Lenfest Institute was created through a philanthropic donation from media tycoon Gerry Lenfest, gifted alongside his ownership of the Philadelphia Inquirer. Editorial and digital strategy manager Joseph Lichterman explains what that has meant.
The Media Archaeology Lab: letting people discover different possibilities for innovation
Since 2009, the Media Archaeology Lab in at the University of Colorado, Boulder, has been welcoming students and the public to get their hands on the not-latest media technologies to help them ask different questions about innovation.
VRT Sandbox: leading the way on startup and media collaboration in Europe
VRT is the public-service broadcaster for Belgium’s Flemish community – but it also welcomes startups and scaleups through its doors with the promise of experience, exposure and even, perhaps, becoming an international export
Altinget: robot, engagement and constructive political journalism innovation
Altinget is building engaged communities around politics across Denmark and Sweden – and making money from it to experiment.
MediaLab EAFIT: Colombian perspective on media innovation
Media innovation methodologies are often created in well-developed media markets, but do they function equally well in different contexts around the world? We spoke to a Colombian university media lab to find out how it approaches its innovation projects.
NRKbeta: public service media innovation for the 21st century
NRKbeta has spent more than a decade developing its expertise where media, technology and society meet – to help Norway’s public service broadcaster, and now the wider Norwegian media – give the people what they need.
Media Labs Days Copenhagen: how automation is changing the news
From Japan to Canada, startups to tech giants, many media are now thinking about and using AI. What does this mean for media workers, readers, and, who’s responsible?
HHlab: Innovating new products and business opportunities
The German media lab focuses on innovation at the business model level, seeking and creating products and commercial opportunities that go beyond the conventions of the news industry.
VPRO Medialab: bringing storytelling to new technologies
The Dutch broadcaster’s media innovation lab uses novel technologies to provide engaging narrative experiences, while also informing its audience about the technologies’ possible impact on their everyday lives.
New report: Media Labs, unlocking change
The continued rise of Media Labs is the focus of the latest 2019 Trends in Newsrooms report. It unpacks their role, examines their organisation and offers advice on what you should do if you want to start one.
Rad, the journalism laboratory of Radio Canada, experiments with formats for young people
In May 2016, Radio-Canada made a strong commitment to innovation by creating Rad, a journalism laboratory that develops formats for young people who get news on the Internet. Since then, the lab has come a long way: two major digital awards, a weekly YouTube news broadcast and effective collaborations with the various teams at Radio-Canada.
Le Tank Media: stimulator of media entrepreneurship
Le Tank Media has become one of the leading actors in media entrepreneurship in France. Using this experience it is now expanding its ambitions, with a 1700 m² space dedicated to emerging media opening soon, as well as other new projects.
WSJ R&D: bringing data science and AI capabilities to the newsroom
The Journal’s R&D unit works across the newsroom to develop new computational approaches to empower journalists with machine learning and artificial intelligence resources.
La Compagnie Rotative, innovation through proximity
“La Compagnie Rotative is the media lab of proximities.” This phrase summarises well the philosophy behind the media lab of the group Centre France. Its approach to innovation is based on closeness between people, local economic actors, and citizens, as well as sharing and creating connections.
Media Labs Day Paris: studying the innovation landscape in news media and other industries
Over 30 media professionals and innovation lab leaders from around the world took part in the fourth edition of the Media Labs Day on 8 April 2019, hosted by Cap Digital in Paris.
MAS: Nice-Matin’s new innovation space
In 2015, Nice-Matin embarked on a profound digital transformation. Faced with major economic difficulties, the daily newspaper opted for a 180-degree turn to establish itself as an innovative media in its own right. Its latest initiative: MAS, the newspaper’s innovation space, launched last January.
Media Lab Days Vienna brought light on innovation experiences and challenges
Media Lab Days Vienna brought light on innovation experiences and challenges Over 20 media lab leaders and innovators from around the world participated in the third edition of the event, this time hosted by the Austrian Press Agency (APA) in Vienna. This edition of Media Lab Days had a different approach to past ones, with a focus on projects rather [...]
Media Innovation Labs survey: In search of what media and news can become
Initial results show different types of media labs within the regions researched, as well as a diversity of projects, which go from digital tools and new narratives to broader journalistic topics, while fostering innovation media culture.
The Annenberg Innovation Lab: ‘Think and Do Tank’ at the University of Southern California (USC)
Headed up by Colin Maclay, they combine nimbleness and network to be innovative both in their local community and on a national scale.
Monday Innovation Lab: Innovating step-by-step, while aiming for Utopia
When you think of innovation labs, you probably imagine a room of people figuring out the next groundbreaking app or tool. Monday Innovation Lab is taking innovation citywide.
Stanford Computational Journalism Lab: Laying the foundations of US data journalism
Working from the ground up, Stanford University is taking a new approach to innovation to provide platforms for journalists to tell stories that would otherwise go untold.
Mediati: incubating new media startups to shake up the legacy media landscape
“If content from old media cannot compete with a 22-year old YouTuber, that’s a problem,” says Mediati’s Content Strategist Simon Park.
Ouest Médialab: a cluster and independent media lab that supports the regional digital transition
Ouest Médialab brings together a variety of actors around digital innovation projects in the French regions Pays de la Loire and Bretagne.
RED/ACCION: both a formal innovation lab and daily experimentation in the newsroom
It’s important to have the space, the resources and the time to experiment and learn on a daily basis in the newsroom. “We don’t want the Maker Lab to be the only place where experimentation and learning take place”, says Chani Guyot.
“Stick to the method and do it by the book, at least in the beginning”
Five questions to Clemens Prerovsky (CDO) about ongoing projects, lessons learned and best practices at the APA-medialab.
FranceTV Lab: testing new tools in the lab first to facilitate adoption in the newsroom
In the lab, FranceTV tests new tools and learns how to use them before introducing them to the newsroom. A way to spread the digital culture among journalists, who tend to be conservative and not always open to new ways of working.
Media and Democracy: research and innovation to strengthen journalism, public discourse and democracy
Media organisations, academics and public institutions work together on experimental innovation and research at Lindholmen Science Park.
Media Lab Days Munich: sharing best practices and brainstorming about looking outwards
Media Lab Bayern in Munich hosted the second edition of GAMI’s Media Lab Days, which means two days of inspiration and brainstorming ended with a tour of a beer brewery.
Next Media Accelerator: the German Press Agency accelerating media and marketing start-ups in Hamburg
NMA aims to offer media and marketing start-ups a place to succeed and provide its 190 stakeholders with strategies for managing the digital transformation at hand.
EPFL+ECAL Lab: innovations should feel natural to users to be sustainable
Innovation is not about impressing people with the latest technologies. For the EPFL+ECAL Lab, an innovation is successful if a user forgets about the technology and instead focuses on the content.
iNOVA Media Lab: research, project development and networking with media
Joining the worlds of social sciences and emerging technologies, by applying their research to media industry practices.
Digital World Research Centre: exploring the interplay between media content, platform and experience
DWRC brings together engineering, communication, social science, business, design and arts to work on media innovation projects that have a concrete impact on society and culture.
Lab 351: innovation-in-a-box approach allows anyone in the company to develop their ideas and entrepreneurial skills
The Globe and Mail encourages all employees in the company to pitch as many innovative ideas as they can even if they are at the back of napkin stage.
AP Lab: including everyone in the organisation in the innovation process
The Associated Press is developing a worldwide hub through internal and external innovation efforts to encourage a culture of experimentation and collaboration within the organisation.
Hackastory: teaching coders and journalists how to collaborate
Building the future of journalism by organising journalism Hackathons where multidisciplinary teams of designers, coders and journalists work together.
InVID : video verification project involving developers, academics and journalists
Short for ‘In video veritas’ (in video, there is truth), InVID is creating a platform that allows journalists to verify video content from social networks more easily.
The Brown Institute for Media Innovation: cross-pollinating innovation and “Magic” on America’s coasts
Exploring new forms of storytelling, with the intent of furthering both engineering research and journalistic practice.
DMJX Media Maker Space: where the Danish School of Media and Journalism meets its community
Not called a ‘Lab’ but a Media Maker Space, because they’re looking for co-creation rather than grand solutions.
J-Lab: aiding new media start-ups through training, consultancy and research
Focused on civic journalism and media entrepreneurship, J-Lab is a US-based national incubation centre that aims to promote digital media innovation within traditional media organisations and journalism start-ups.
Texas State University MILab: Introducing media innovation into university teaching
Through their work with Web development, virtual reality/360 video, drone journalism and multimedia storytelling, the team is looking to influence digital media disciplines.
Théophraste: building relationships within the company and with the start-up ecosystem
The French Sud Ouest newspaper in Bordeaux is inviting local start-ups to share office space and resources from within the organisation to help accelerate their development.
Independent Lab: developing products through developing people
The lab within Independent Media is training technology graduates in media, so they get can apply technology in the newsroom and innovate in the media sector.
Roularta Mediatech Accelerator: media for equity for advertising and media technology startups
Roularta Mediatech Accelerator is a programme initiated by the Roularta Media Group, together with Duval Union, to provide support and guidance for media technology startups.
Media Innovation Studio: international research, creative methods and multidisciplinary approaches
UCLan’s Media Innovation Studio is a research centre and learning media lab which engages in a broad variety of media activities, including drone journalism, progressive media teaching, media research and product development.
Media Lab Bayern: an incubation unit for digital media development and innovation
Focused on digital journalism innovation, Media Lab Bayern is a co-working incubation unit for media innovation startup companies which provides journalism and entrepreneurship aid and coaching for media development.
University of Vienna MiLab: innovating media through academic research
University of Vienna’s Media Innovation Lab (MiLab) is a research-based unit which examines the development of new media technologies and evolution of media innovation, while also analysing the impact new media has on the public and society.
Arizona State University New Media Innovation and Entrepreneurship Lab: cutting-edge media innovation through app development
Arizona State University New Media Innovation and Entrepreneurship Lab is a research and development unit which focuses on producing cutting-edge products for media companies and educating students from various departments to enhance the regional and national media system.
BBC News Labs: collaborative unit for media innovation and product development
BBC News Labs is a collaborative, multi-disciplinary unit which focuses on developing digital innovation tools to solve issues within the media and improve news content.
University of Kansas Media Innovation Lab: bringing students, professors and industries together for media innovation
University of Kansas Media Innovation Lab is a multi-disciplinary lab which combines academic research with digital product development and teaching in order to foster media innovation, as well as help develop new project ideas.
AFP Medialab: information verification and user experience at the core of newsroom innovation
A small team of journalists and engineers are developing new tools for the newsroom and building innovative user experiences to valorise AFP’s content.
NewsThings: exploring what the Internet of Things could be for news and information
This collaborative project aims to understand how journalism could harness connected things to find new ways of connecting with people and conveying stories, and to create prototypes that will allow this in the near future.
INJECT: a journalism and technology project building creativity tools for journalists
The INJECT project unites 14 partners in 6 European countries in the development of new digital technologies for news organisations.
Nordjyske Startup: incubator within the second oldest media company in Denmark
In return for new ideas and knowledge, media house Nordjyske Medier offers startups its expertise and network to develop their businesses further.
APA-medialab: innovating journalism through prototypes and trend research
An interdisciplinary team of developers, designers, journalists, researchers and marketeers are working together on ideas for new products and services.
Time Inc UK Innovation Lab: accelerated product development
Insights, intelligence, incubation and propagation – How Time Inc. UK adopted rapid development to drive new products.
Drone Journalism Lab: action research and innovation
The Lab’s work is to equip journalists and the wider industry with the skills and knowledge they’ll need for the future
Knight Lab at Northwestern: Q&A with Professor Joe Germuska
Northwestern University Knight Lab builds software that helps inform and engage the public
NYC Media Lab: a public-private partnership for innovation
NYC Media Lab unites New York City-based companies, researchers and students to drive digital media development by creating an ‘open innovation ecosystem’
Stibo Accelerator: inviting students and startups to help boost creativity and innovation
Inviting students and startups in to help boost creativity and innovation
NTNU – Sense-IT
The Norwegian University of Science and Technology’s Sense-IT Lab is exploring 3DTV, augmented media, immersive experiences and whole body interaction techniques
NxtMedia: a collaborative network for innovation
Harnessing multi-skilled networks in Norway and beyond to create internationally-recognised innovation
Amaury Lab: a startup incubator led by a publisher
Amaury Lab brings together startups and entrepreneurs with the established Amaury Group publishing house to collaborate innovate, develop new projects and share creative approaches.
Asahi Shimbun Media Lab: internal innovation
An independent department for brainstorming and testing out new concepts using Asahi’s existing skills and assets.
Sud Ouest’s Théophraste: in-house acceleration and collaborative enterprise
Bordeaux’s Sud Ouest newspaper’ startup lab – Théophraste – invites local startups to share office space and resources to help accelerate their development.
Open Lab
A cross disciplinary approach to digital technology driven by users and participatory innovation.
Centre for Community Journalism: engaging and innovating
C4CJ offers one-to-one support, hyperlocal journalism hubs and massive open online courses with global reach and thousands of participants
Pervasive Media Studio
Creating innovation through a multidisciplinary collaboration,
Tags
academic Lab
academic research
accelerator
AI
Austria
automation
business coaching
business models
cluster
culture of innovation
data journalism
data science
Denmark
design sprint
design thinking
digital creativity
France
funding
Green media
Hackathon
horizon 2020
Immersive
incubator
industry collaboration
internal innovation
machine learning
multidisciplinary
network
news agency
newspaper
open innovation
partnerships
personalisation
prototypes
software
sports
startups
students
Sweden
tools
training and education
UK
USA
UX
virtual reality