<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sam Hendrickx on Medium]]></title>
        <description><![CDATA[Stories by Sam Hendrickx on Medium]]></description>
        <link>https://medium.com/@samhendrickx?source=rss-9bf89b54bad6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*As33Hq9ewL_45694.jpeg</url>
            <title>Stories by Sam Hendrickx on Medium</title>
            <link>https://medium.com/@samhendrickx?source=rss-9bf89b54bad6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 12:36:16 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@samhendrickx/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Digitizing subsidies at Sint-Niklaas]]></title>
            <link>https://medium.com/raccoons-group/digitizing-subsidies-at-sint-niklaas-640ee57f4348?source=rss-9bf89b54bad6------2</link>
            <guid isPermaLink="false">https://medium.com/p/640ee57f4348</guid>
            <category><![CDATA[tpo-agency]]></category>
            <dc:creator><![CDATA[Sam Hendrickx]]></dc:creator>
            <pubDate>Fri, 17 Feb 2023 10:19:17 GMT</pubDate>
            <atom:updated>2023-02-17T10:19:44.663Z</atom:updated>
            <content:encoded><![CDATA[<p>The city of Sint-Niklaas has decided to work on digitizing its grants and subsidies to improve its services for its citizens and businesses. The old system of paper applications, processing, and verification was extremely time-consuming, making the subsidy granting process lengthy and intrusive. Digitizing the system with LB365 offers a more efficient and accurate way to process grants and subsidies.</p><figure><img alt="sint-niklaas" src="https://cdn-images-1.medium.com/max/1024/0*VC068TgozpgVOjB0.jpg" /><figcaption>Sint-Niklaas</figcaption></figure><h4><strong>LB365</strong></h4><p>With LB365, applicants can easily and quickly apply online, speeding up the processing of the applications. The system is also built with automation in mind, making the process of verification and evaluation of the applications easier and faster. Furthermore, automation reduces human error, leading to better accuracy of processing.</p><figure><img alt="subsidies" src="https://cdn-images-1.medium.com/max/1024/0*M69zhmnasJfhzQAz.png" /><figcaption>Subsidy request</figcaption></figure><p>For instance, when an applicant submits an application, this person will automatically receive e-mails throughout the process. These e-mails keep the applicants informed of the status of their application or tell them to take extra actions such as submitting extra supporting documents.</p><p>In addition, applicants will also have access to a digital overview where all their applications are listed: the “E-loket” of Sint-Niklaas. In this digital overview, the applicant can quickly consult the necessary information. For example, they can see what status of the application and who the person handling it is.</p><figure><img alt="e-loket" src="https://cdn-images-1.medium.com/max/1024/0*BFk3i4RGrZVTSdJO.png" /></figure><h4>An efficient collaboration</h4><p>Sint-Niklaas has decided to collaborate with Cronos Public Services and TPO Agency to guide and guarantee the digitization process. Cronos Public Services specializes in digital solutions for government organizations, and TPO Agency is an expert in automation and digitization. Together they offer a complete solution for managing grants and subsidies, enabling Sint-Niklaas to provide fast and efficient services.</p><figure><img alt="platform" src="https://cdn-images-1.medium.com/max/1024/0*kb_mdzDGOMqqpYVK.png" /><figcaption>The platform</figcaption></figure><h4><strong>The benefits of digitizing subsidies</strong></h4><p>Digitizing grants and subsidies with LB365 offers many benefits for Sint-Niklaas, its citizens, and businesses. The subsidy granting process becomes faster and more efficient, improving the services provided to the citizens and businesses in the city. Furthermore, the system saves time and costs, meaning that Sint-Niklaas can allocate these resources to other projects and initiatives that contribute to the growth and prosperity of the city.</p><p>In conclusion, digitizing grants and subsidies with LB365 offers Sint-Niklaas a more efficient and accurate way to process them, leading to better services for its citizens and businesses. Read more about the project <a href="https://www.sint-niklaas.be/actueel/persberichten/eerste-stedelijke-subsidies-voortaan-online-aan-te-vragen">here</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=640ee57f4348" width="1" height="1" alt=""><hr><p><a href="https://medium.com/raccoons-group/digitizing-subsidies-at-sint-niklaas-640ee57f4348">Digitizing subsidies at Sint-Niklaas</a> was originally published in <a href="https://medium.com/raccoons-group">Raccoons Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[An interactive and unique experience for De Warmste Week]]></title>
            <link>https://medium.com/craftworkz/an-interactive-and-unique-experience-for-de-warmste-week-cb77bb157cbc?source=rss-9bf89b54bad6------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb77bb157cbc</guid>
            <category><![CDATA[case]]></category>
            <category><![CDATA[craftworkz]]></category>
            <dc:creator><![CDATA[Sam Hendrickx]]></dc:creator>
            <pubDate>Fri, 13 Jan 2023 08:36:44 GMT</pubDate>
            <atom:updated>2023-01-13T08:37:23.491Z</atom:updated>
            <content:encoded><![CDATA[<p>De Warmste Week, a solidarity campaign by VRT, warms the hearts of thousands of Belgians each year. If you haven’t heard of it yet (which we doubt, but to be sure!), here’s some context. From the 19th to the 24th of December, Eva De Roo, Sander Gillis, Kawtar Ehlalouch, and Fien Germijns make live radio from six in the morning until midnight in Het Warmste Huis.</p><p>The radio hosts highlight stories of campaigners who raised funds during the past year for underprivileged people. This is an important issue to call attention to, as being underprivileged is more than income poverty. Being underprivileged is a multi-dimensional concept where people are limited in their opportunities to participate adequately in socially highly valued goods such as education, employment, and housing. VRT called on us to produce a highly interactive and unique experience to reward the campaigners.</p><figure><img alt="de warmste week hosts" src="https://cdn-images-1.medium.com/max/1024/0*0TMDDJloBpVjXw15.png" /></figure><figure><img alt="het warmste huis" src="https://cdn-images-1.medium.com/max/828/0*jctpy9IcE2ieRy5d.jpg" /></figure><p>De Warmste Week</p><h4>The interactive experience</h4><p>People who organized a campaign to raise money get to tell their stories on stage on live radio or in one of the on-site video booths. While they wait their turn to bring their anecdote, they create their personal flame.</p><p>The personalization happens on their smartphone via an interactive web experience. The campaigners can choose between different outfits, accessories, and looks to create a flame that fits their identity. Once they compose a character, the website returns a unique QR code which they can scan in the video booths or on stage. The flame is now waiting for them to push the big red button. Once they push the button, it will come to life in the virtual worlds on the LED screens on top of the radio house.</p><p>Het Warmste Huis</p><h4>Building the application</h4><h4>Ideation</h4><p>Like most ideas, our final concept originated from good old brainstorming. Together with VRT’s Creative Director, we needed to come up with an idea that was both technically feasible, could function standalone, and, at the same time, had to be fun and interactive. In addition, the concept had to be suitable for both young and old, as De Warmste Week reaches a vast audience.</p><p>So, after brainstorming, we came up with an idea that ticked all our boxes. The symbol for De Warmste Week has always been a flame — so what if we gave everyone a personal one? This was it. We started building.</p><h4>Personal flames</h4><p>Together with our sister company, Embassy X, we created the designs and built an interactive and accessible website where campaigners can compose their personal flame. You can give it certain clothes — pants, skirts, bows — and even accessories — think of earrings or a crown — so the flame can genuinely be your own.</p><figure><img alt="personal flames" src="https://cdn-images-1.medium.com/max/1024/0*EsMdETyX08MoM6hn.png" /><figcaption>Personal flames</figcaption></figure><p>Of course, to show the strength of the personalized flames, we made a few examples. We gave each of the hosts a personal character, in addition to the main sponsor, KBC, who received a blue flame.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_7bldd-xDkTLAMpx.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/818/0*PPMyWnBAvfFIuSgT.png" /></figure><p>Hosts &amp; KBC flames</p><h4>Het Warmste Huis</h4><p>When a campaigner gets to tell their story on air and push the big red button at the end, their flame will come to life on the roof of Het Warmste Huis. More specifically, when the button is pushed, the audience will hear a recognizable tune, the screens around the house light up, and the flame literally flies up to the middle of the roof. In addition, the flame will show up in the studio, so the campaigner in question see it as well. To make it even more interactive, they can make the flame jump and dance around by controlling it on their smartphone.</p><p>Het Warmste Huis</p><h4>The interactive worlds</h4><p>In total, we designed and developed five unique worlds: a basic, snow, candy, grass, and disco world. Each of these worlds has a very distinct look and feel, with custom 3D assets as the cherry on top.</p><p>The virtual worlds can be managed via an admin panel in real-time. By pressing a button, worlds can be switched; personal flames can be added, removed, or even put to dance or jump around. In this world, the flames can truly live their lives and walk around.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5U7IOXB00-rh_7-O.JPG" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OMppYtnZg47HSSnI.JPG" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QN75pLNTSp6Le-bI.JPG" /></figure><p>The virtual worlds</p><h4>The digital Christmas tree</h4><p>De Warmste Week is all about bringing people together. Everyone is welcome, of course, even if they did not raise funds or campaign. In the city of Hasselt, anyone gets the chance to make their personal flame dance.</p><p>You start by creating your own flame and scanning your QR code at the base of the Christmas tree. Immediately, the lamps above the LED panels start flashing, and your character comes flying in at the top of the tree. Then, it walks around the tree twice — using the garland as its path — while you can make it dance or jump around using the controls on your smartphone. Once arrived at the bottom of the tree, it sticks around for a few moments and then disappears.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2_Czox7aW4HuGqud.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vkGepJtNUZyZvrnS.jpg" /></figure><p>The digital Christmas tree</p><h4>Video booths</h4><p>As only a select group of people can bring their stories on air, we also wanted to enable other campaigners to show off their efforts. Any campaigner can access a De Warmste Week video booth on one of the sites to shoot a video to tell their story. Of course, we couldn’t forget their personal flame! When they are done recording the video, they can press a red button for the flame to function as an overlay.</p><p>To make this even more fun, these flames also appear on the roof of Het Warmste Huis. They don’t come flying in as the others — that would lead to ultimate chaos — but they do come to life by popping in via the sides of the screens.</p><p>How we made this possible technically? By scanning your QR code at the scanning station, the attached NUC ran a NodeJS program to capture the QR code and send the information to the server. Moreover, we had a NodeJS web server running on an AWS EC2 Instance. This server was used to host the website, create QR codes, create and maintain sessions, and communicate between users, scanners, and all Unity instances.</p><p>In total, we had four Unity instances running simultaneously. One for the main stage, two for the action villages, and one for the interactive Christmas tree.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rg-MFM3Y0_sxDt0s.jpg" /><figcaption>Technical set-up</figcaption></figure><h4>3D</h4><p>However simple these flame characters may seem, we chose to fit them with a full character animation control rig to allow as many poses and tweaks as possible. The rig has a built-in system to outfit our little flame with all the clothes, jewelry, and accessories to create as many variations as (in)humanly possible — all of this while allowing secondary animations while they are jumping, walking, or dancing.</p><p>We added as many details as possible, like hats, crowns, and headphones bobbing around or earrings wiggling — all that good stuff. The four presenters got their personalized hair assets, making them recognizable to the viewers outside the house.</p><h4>3D worlds</h4><p>All worlds were built for real-time purposes, and they had to fit within the correct frame mapping of the screens on top of the Warmest House. We had to juggle angles, walkable space, viewing angles, and real-time framerates to get this working for all five universes the flames reside in.</p><p>We also added extra offscreen elements to anticipate other screens or aspect ratios to ensure the content was there and ready for changes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*k0CwXHtrhZfpObt5.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_q-CmZjLMHdS0Qg_.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*r9wfKy6IceQeyA-F.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gkv_IRQXmiQM8vVP.png" /></figure><h4>Rigging and animation</h4><p>We modeled, animated, and hand-painted all assets within the 3D application to preserve the specific character design of the flame character.</p><p>The hero/appear animation was a challenge because the options to animate are limited if the character has no arms. Luckily, this was hugely compensated by the availability of two knees on each oversized leg…</p><p>Animations also had to be designed in a way they are loopable forever and can cross over into the next animation, like going from an idle loop into a walk and then bursting into vivid dancing and back into an idle loop again.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/0*Nu2bmd6Ju3udvlK_.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/0*sd5m0eCEkjwB6R5r.png" /></figure><p>Animation</p><h4>UI &amp; copywriting</h4><p>With the help of Embassy X, we enhanced our characters and application in terms of copywriting and user experience. Regarding copywriting, we had to keep a few requirements in mind. For instance, the tone of voice had to match all communication around De Warmste Week. As this initiative reaches both young and old, communication had to be understandable for all. This means scratching all difficult words and simplifying the navigation by using intelligent, intuitive micro-copy within the brand voice.</p><figure><img alt="de warmste week app" src="https://cdn-images-1.medium.com/max/393/0*jpC8LfZUcdx7p2e8.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/393/0*voLEgqqOFXBi-sCG.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/393/0*k9IQmIb7Ujk-u-Qw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/393/0*8KutvVvDplLJih8J.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/393/0*jf9gOZ8E0n0OTe2a.png" /></figure><p>When it came to UI, the application had to be easy and intuitive, all fitting into the style guide of De Warmste Week. Of course, we also wanted the user to get the best experience possible, so we focused a lot on UX design. This started by expanding the necessary user flows. For instance, when putting a character together, the’ happy’ flow had to guide the user through the application by clarifying the different categories and configurations. For instance, much thought went into the confirmation and success pages. Of course, we also had to define the ‘unhappy’ flow — anticipating potential errors when scanning, creating, and saving characters.</p><p>To enhance the user experience even more, we integrated more visual support. For instance, we added an image of the scanner, so people knew what they had to look for in advance.</p><p>Last but not least, the application had to be compatible with any mobile phone, including the new iPhone with a dynamic island. To accommodate this, we adjusted the logo and button placement accordingly. In essence, much thought went into creating the most frictionless and fun user experience possible.</p><h4>Team</h4><p>Client: Simon Van de Gracht <br>Brand: VRT, De Warmste Week <br>Creative Director: Joachim Vandoorne <br>Design: Jean Nguyen Huy, Ward Rombaut, Kamiel Bral <br>Unity, back end, and hardware development: Wim Vanhenden <br>Front end developer: Aagje Reynders <br>3D: Kurt Drubbel <br>Client Director: Hannah Patronoudis <br>UX/UI: Ashley Noben <br>Copywiriting: Sigrid Spaas, Katrijn Van Hauwe <br>Lichtontwerper: Karel Perneel <br>Chef techniek: Wouter Degrave <br>Video en audio: Jo Pauly</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb77bb157cbc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/craftworkz/an-interactive-and-unique-experience-for-de-warmste-week-cb77bb157cbc">An interactive and unique experience for De Warmste Week</a> was originally published in <a href="https://medium.com/craftworkz">Craftworkz</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is your team building products or creating solutions?]]></title>
            <link>https://medium.com/raccoons-group/is-your-team-building-products-or-creating-solutions-ea7cad3f360?source=rss-9bf89b54bad6------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea7cad3f360</guid>
            <category><![CDATA[tpo-agency]]></category>
            <category><![CDATA[product-owner]]></category>
            <dc:creator><![CDATA[Sam Hendrickx]]></dc:creator>
            <pubDate>Mon, 19 Sep 2022 15:09:50 GMT</pubDate>
            <atom:updated>2022-09-19T15:10:12.212Z</atom:updated>
            <content:encoded><![CDATA[<p>From experience, I can tell you that the process of building products is expensive and complex. A common mistake product teams still make is starting by thinking about the actual product rather than discovering why and for who they are building this product.</p><p>A quote from Silicon Valley product group guru Marty Cagan says, “<strong><em>First, you need to discover whether real users out there want this product… Second, you need to discover a product solution to this problem that is usable, useful, and feasible.”</em></strong></p><p>As a product manager, this resonated with me and forced me to ask: Is my team building products or creating solutions? Let’s explore the difference between the two.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ekn1bMwOAw3CZPIf.jpg" /><figcaption>Our team prioritizes user research early on in the process</figcaption></figure><h4>The four main differences</h4><p>From my experience, I’ve found that there are four main differences between teams that build products and teams that create solutions:</p><ol><li><strong>Teams that build products think about what they <em>can</em> build, whereas teams that create solutions think about what they <em>should</em> build</strong>. There is a big difference between these two things. The former is driven by feasibility and what the team sees as possible, while the latter considers the feasibility and whether it will solve the user’s problem.</li><li><strong>Teams that build products focus on <em>features</em>, whereas teams that create solutions focus on <em>outcomes</em></strong>. This one is self-explanatory — features are what you build, while outcomes are what you achieve. Simply put, focusing on results means ensuring that whatever you make will help achieve the business goals.</li><li><strong>Teams that build products work in <em>silos</em>, whereas teams that create solutions work in <em>cross-functional </em>teams</strong>. To be successful, product development needs to be a collaborative effort between different departments, such as design, engineering, marketing, and so on. Working in cross-functional teams ensures everyone is on the same page and working towards the same goal.</li><li><strong>Teams that build products rely on <em>assumptions</em>, whereas teams that create solutions rely on <em>data</em></strong>. Assumptions are dangerous because they can lead you down the wrong path entirely. Relying on data means making decisions based on evidence instead of just guessing — which gives you a much better chance of success.</li></ol><p>Building products is an expensive and complex process — there’s no doubt about that. But it’s even more complex and costly if you’re not building the right thing. That’s why it’s essential to ensure you’re thinking about why you’re building something and who it’s for — otherwise, you might <strong>waste time and money on</strong> <strong>something nobody wants or needs</strong>. So ask yourself — is your team building products or creating solutions? The answer could make all the difference in your success (or failure).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea7cad3f360" width="1" height="1" alt=""><hr><p><a href="https://medium.com/raccoons-group/is-your-team-building-products-or-creating-solutions-ea7cad3f360">Is your team building products or creating solutions?</a> was originally published in <a href="https://medium.com/raccoons-group">Raccoons Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Discovering FlutterFlow: the good, the bad, and the ugly]]></title>
            <link>https://medium.com/craftworkz/discovering-flutterflow-the-good-the-bad-and-the-ugly-9bb8493464a9?source=rss-9bf89b54bad6------2</link>
            <guid isPermaLink="false">https://medium.com/p/9bb8493464a9</guid>
            <category><![CDATA[craftworkz]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[flutterflow]]></category>
            <dc:creator><![CDATA[Sam Hendrickx]]></dc:creator>
            <pubDate>Mon, 12 Sep 2022 10:54:43 GMT</pubDate>
            <atom:updated>2022-09-12T10:55:38.836Z</atom:updated>
            <content:encoded><![CDATA[<p>Earlier this year, I learned how to work with Flutter. To be honest, I did not particularly like it. To be fair, I liked it more than the alternatives, but I quickly got lost in the structure. For example, you need to place text in a button in a column in a row in a container. To me, it felt like a puzzle. I had to figure out how to place the pieces and, on top of that, work out which pieces I needed to use. Until I discovered FlutterFlow.</p><p>When I discovered FlutterFlow, I was pretty excited but also skeptical. Low-code (and no-code) platforms have been popping up everywhere lately and are gaining attention. I understand the appeal to people with no or little development experience. Still, personally, I find that those platforms, while making front-end development very easy, they can also make some things very complicated. I sometimes find myself thinking: coding would have been more straightforward. However, since I like trying new things, I made an account on FlutterFlow and started experimenting. Spoiler alert: I was pleasantly surprised!</p><p>A quick note: this blog will not be a technical review of how you do certain things in FlutterFlow. I will describe my experience working with FlutterFlow: the things I noticed, the things I liked, and the things I didn’t like.</p><h4>Creating a project</h4><p>When you start to create a project, FlutterFlow offers a lot of templates, like any other low-code platform. What I liked most is that when you hover over a template, you can see what features are used in that particular template. I double-checked, and Webflow, for example, also informs you of the features, but you have to click twice and be directed to a different page to see them. Let’s be honest, you might do that to check out one or two templates, but it quickly becomes too much of a hassle. So good points on user experience for FlutterFlow!</p><figure><img alt="Creating a new project in FlutterFlow" src="https://cdn-images-1.medium.com/max/1023/0*MaRAPbR-jcVHkLjU.jpg" /><figcaption>Creating a new project in FlutterFlow</figcaption></figure><h4><strong>Creating a page</strong></h4><p>When you start creating a page, FlutterFlow offers templates for commonly used pages like settings and log-in. After selecting a template, FlutterFlow immediately asks if you want to keep the original theme of the template or use the theme you chose for your project. This means you can create an entire page for your app in a mere two clicks.</p><p>There is, of course, not a template for every page you might need. So, I also tried making a page from scratch. FlutterFlow offers a list of elements you can drag and drop on your page. Some essential elements include text, button, image, and handy features like animations, charts, and map integrations. I spotted ‘column’, ‘container’, and ‘row’ in the list, and for a moment, I thought I still had to puzzle the front-end together. But no worries! You can use them if you want to, but you don’t need to.</p><p>When dragging elements on the canvas, FlutterFlow will ask you how you want these elements placed: do you want them next to each other, do you want them underneath each other, … Based on your answer, it will add the correct structure around your elements. Very convenient!</p><figure><img alt="FlutterFlow asks what structure to apply when creating a page" src="https://cdn-images-1.medium.com/max/700/0*tJ0w6mV6CKJkMVto.jpg" /><figcaption>Building a page in FlutterFlow</figcaption></figure><p>You can edit every element on the right side of the interface. This is a standard approach, but I mainly noticed how all the buttons felt intuitive. I didn’t have to think about what this icon might mean or do. For some extra explanation, you can always hover over the button. The only inconvenience I found is that you can’t increase or decrease the value of a number with the arrow keys, which is a tiny issue, but it is also something I do often.</p><figure><img alt="The interface to create a page, with on the left side a tree structure and on the right side edit options" src="https://cdn-images-1.medium.com/max/1024/0*akJTOoOUdRT9JcvT.jpg" /><figcaption>The FlutterFlow interface</figcaption></figure><h4><strong>Adding a custom widget</strong></h4><p>One of the strengths of Flutter is the vast community of people creating custom components. I wanted to see if FlutterFlow has the same kind of community, as it is a very convenient way to integrate original and complex components. I was pleased to see you can use the packages of the Flutter community (<a href="https://pub.dev/">pub.dev</a>) and incorporate them into your Flutterflow project. You have to pay attention to two things: the packages need to be supported for the web and need Null Safety support. New packages mostly fit the requirements; old packages usually don’t.</p><p>When trying out the custom widget feature, I experienced some significant flaws for the first time since working with FlutterFlow:</p><ul><li>The code editor shows errors on anything imported. It clearly states you should ignore them, but it makes the actual errors less visible, not to say unnoticeable.</li><li>It takes around 2 minutes to compile the written code, meaning that every time you change the code, you will have to wait 2 minutes to see the change.</li></ul><p>This does slow down the process a lot. For example, you write some code, and you forget a comma. You don’t notice it since there are a lot of errors anyway. So, you start compiling the code. After two minutes, FlutterFlow tells you that you forgot a comma. So, you add the comma and have to compile again for two minutes. Not ideal.</p><figure><img alt="The custom widget code editor" src="https://cdn-images-1.medium.com/max/1024/0*MLoXn8g2Y0OkSjpL.jpg" /><figcaption>Creating a custom widget</figcaption></figure><h4><strong>FlutterFlow Documentation</strong></h4><p>While doing my little experiment, I consulted the FlutterFlow documentation several times. FlutterFlow has by far one of the best documentation I have ever seen. They explain everything, assuming you don’t have any previous knowledge, meaning it is effortless to understand. Every topic is also accompanied by a couple of GIFs that visually explain what the text is talking about. And if that is still not enough, FlutterFlow also refers to video tutorials on <a href="https://www.youtube.com/channel/UC5LueiosDVInA6yXE_38i9Q">YouTube</a> that explain everything step-by-step. I hope they keep the documentation and tutorials up-to-date with future updates.</p><h4>Conclusion</h4><p>Next time I need to make a Flutter app, I will definitely use FlutterFlow. It is much easier, more intuitive, and quicker than building a Flutter app from scratch. However, I do hope the app won’t need too many custom integrations because that would be a real hassle. Have you already used FlutterFlow? Let me know what you thought!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9bb8493464a9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/craftworkz/discovering-flutterflow-the-good-the-bad-and-the-ugly-9bb8493464a9">Discovering FlutterFlow: the good, the bad, and the ugly</a> was originally published in <a href="https://medium.com/craftworkz">Craftworkz</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Code optimization: changing the way you approach repetitive tasks]]></title>
            <link>https://medium.com/brainjar/code-optimization-changing-the-way-you-approach-repetitive-tasks-db02b857b4d7?source=rss-9bf89b54bad6------2</link>
            <guid isPermaLink="false">https://medium.com/p/db02b857b4d7</guid>
            <category><![CDATA[brainjar]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Sam Hendrickx]]></dc:creator>
            <pubDate>Wed, 06 Jul 2022 11:42:26 GMT</pubDate>
            <atom:updated>2022-07-06T11:43:27.803Z</atom:updated>
            <content:encoded><![CDATA[<p>Imagine: you are working on a specific problem. After much trial and error, your code finally does what it is supposed to do. The solution is neither elegant nor very efficient, but you have already spent more time than you wanted to. You tell yourself you will refactor the code somewhere in the future. As time goes by, you obviously do not find any more time (or desire) to do so, and you leave your code as it was. After all, the code works, and you have much more important issues to deal with first. Sounds familiar?</p><p>Fast forward to the moment you are ready to put everything into production. You notice that a small part of the pipeline is remarkably slow. You dive into the code, and you identify the problem. Shock. It is the code you had written months ago that you told yourself you would refactor at some point. Well, that moment has finally arrived.</p><p>According to a famous ancient quote (originating in the 1960s) from Donald Knuth (“Premature optimization is the root of all evil”), this workflow is completely fine. The premise of that quote originates from the logic that programmers spend far too much time on things they may not need in the end. Examples include optimizing a preprocessing function that eventually does not make it to production. Another example is prematurely scaling to millions of users while you are still a scale-up and only have a couple of users.</p><p>In this blog post, I’m not going to tell you that Donald was completely wrong or that his reasoning is outdated. Instead, I mainly want to give you some do’s and don’ts pointers, how you can identify possible optimizations in your code, and how to optimize it.</p><h4><strong>The power of vectorization</strong></h4><p>First, I would like to introduce you to a very basic toy example. Assume we have an array of integers, and we would like to randomly sample an increase between 0 and 2 for each value in the array. We can solve this in various ways. I have outlined three of them with their corresponding computation times for various data lengths.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/954/0*ZLsQ7AUgJHLwgoBc.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LRpVgGFRYimJAA4o.png" /></figure><p>For this effortless task, we see that the classic for loop is a tad slower than the list comprehension. The difference comes from the additional overhead of appending. However, both are much slower than the ‘vectorized’ method, for which the effect increases as the data gets larger.</p><p>By only sampling once, we could eliminate significant overhead and take advantage of the numpy computations (which are implemented in C), which can be computed in parallel. Without going into too much detail, vectorization reduces the number of CPU instructions, memory reads, and cache misses. More recent versions of numpy also take advantage of parallelization with SIMD (Single Instructions Multiple Data). In essence, vectorization is transforming your code so that it can be automatically translated to machine code instead of the default slow python code.</p><p>Since vectorization works so well because it minimizes costly operations, I would like to introduce a concept I like to call ‘pseudo-vectorization’. Within pseudo-vectorization, you first identify the potential bottlenecks/costly operations in your code. Then, you try to reduce those by preprocessing/cleverly transforming your data. But how can we identify these potential bottlenecks in our code now? This is where line_profiler comes in.</p><h4><strong>Identifying and solving bottlenecks in your code</strong></h4><p><a href="https://pypi.org/project/line-profiler/">Line_profiler</a> is a convenient package showing the time individual code lines take to execute. It is straightforward to set up, and with a few lines of code, you get an incredibly insightful overview of the execution time of a particular function. The function from the image returns a slightly modified time series data frame for a day with 24 timesteps. It only needs to modify specific columns with randomly sampled nearest existing values, and certain values needed to remain constant (due to the nature of the scale of certain variables).</p><p>To reduce the computation time, the first step is to compute this information/metadata once and pass it to the function. Since this was a function that had to be applied tens of thousands of times, waiting times accumulated. I decided to have a look at it with line_profiler. The output was quite shocking. Rather than trying to optimize for lines within the function, it was the return line that took over 85% of the total computation time. The function we had written turned out to be quite efficient, but it was merely the final step of creating a data frame from an array and assigning the original columns that were so expensive. By simply returning the array, we sped up our code by a factor of almost 10.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*J-GCID9jH9UsJWyl.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Xijm0H6waQegNHkt.png" /></figure><p>But Olivier, now our function returns an array instead of a data frame. That’s not what we want. Yes, I know, and that is what I was referring to during my introduction to pseudo-vectorization. You will often have to make slight but intelligent modifications to your pipeline to benefit from it. Instead of always returning a data frame, you should slightly adapt your code. This way, you only create a data frame once after concatenating all numpy arrays from our adapted function. With some minor changes in your code, that part of the pipeline is now 10 times faster.</p><p>You could go even further and vectorize the loops if you want, speeding up the function. However, vectorizing too much can sometimes be detrimental to your code’s readability, as observed from the image below, which does the same as the previous functions. As a rule of thumb, I wouldn’t start to maniacally vectorize everything if there is no real need. Nevertheless, it is an instrumental skill to have in your pocket.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pVh-qHP3FY_KRFhH.png" /></figure><p>Of course, it is not always as straightforward or easy as in this example. Identifying and fixing bottlenecks in your code is a learning experience. It is something you will get better at as time progresses. Especially vectorizing your code can be pretty challenging at first. The most impactful optimizations originate from processes that need to be repeated multiple times.</p><p>Another example from a real case study is calculating the feature importance for a time series classification problem. Since we couldn’t rely on an existing package due to the multi-output of the model and multivariate time series input, we had to write our implementation of the Shapley values. In that instance, I had written a method that calculated the feature importance case by case, rerunning the predictions with every case. Initially, this was fine, but as the project matured, this started to become a problem.</p><p>Eventually, I decided to rewrite the method. I identified that the main performance issues came from running the predictions so many times (we had hundreds of features, so for one case, we had to perform inference already close to a thousand times). I rewrote the code so we would only run the predictions once but with large batch size. Again, this required some changes to the pipeline (you had to keep track of some metadata and then eventually assign the concatenated predictions to that metadata). Still, the potential speedup (which I had first verified) was enormous, resulting in a method that was now 15–20x faster. Although optimizations are often in the form of a for loop or a list comprehension, this is not exclusively the case. Applying a custom function inefficiently multiple times can also cause severe troubles, which we will see in our next section.</p><h4><strong>Assessing the efficiency of pandas</strong></h4><p>Import pandas as pd is probably the number one used import of all data scientists and is perhaps on top of basically every one of your notebooks. And with good reason. It is convenient, user-friendly, and reasonably fast, right? But how efficient is the pandas library? And when should we use it?</p><p>Since pandas uses numpy under the hood, almost all of the build-in methods in pandas are fast. As opposed to numpy, they are specifically designed to work well with tabular data of different types (strings, integers, lists, etc.). It is also considered faster if you have more than 500k observations. The main drawbacks of the pandas library are that it consumes much more memory than numpy. Moreover, indexing is ridiculously slow, compared to numpy, which excels in both aspects. As a rule of thumb, I would suggest converting to numpy if you are solely working with numerical data, if you can not resort to the build-in pandas methods, or if you are considering using the pandas build-in method.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ympbVg43rrcL5SZt.png" /></figure><p>Imagine: you want to apply a custom function on multiple columns of your data frame for the first time. A quick google search later, you will probably have learned about <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.apply.html">pandas.DataFrame.apply</a>. You copy-paste one of the first answers on StackOverflow, tweak it to your data frame, and the code exactly does what you want it to do. It might be a bit slow, but hey, it was the top answer on that StackOverflow thread. Surely, there won’t be a better solution to this, right?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WMVKjk1cD_ZjsqbV.png" /></figure><p>Let’s put that to the test. As a proof of concept, I have created a toy function that scales the number of flights based on an airport-specific maximum value previously stored in a dictionary. It thus requires exactly two columns from the data frame. We will start by assessing the performance of the often recommended apply-syntax.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*H-nuAY4LcwPlUwG-.png" /></figure><p>2.7 seconds for a little more than 20.000 observations. Not great, but reasonable. At first. Somewhere along my first project, I remember waiting almost half an hour for an apply function to finish on a data frame of a couple of million rows. I remember doing this a couple of times until I finally was fed up with it. I did what every programmer does in that situation: consult Google and look for better alternatives. One of the first suggestions I came across was using a list comprehension combined with zip. So, I took over the suggested syntax and started to wait. For merely 15 seconds. This alternative was over 100 times faster. How is that possible? And why does apply exist then?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-gLD1pAzvkF15RDS.png" /></figure><p>Let’s look at our toy example. The situation above did not happen to be a lucky shot. Apply is indeed ridiculously slow. But why? Apply is a bit of a misfit within the pandas family. It is a wrapper/silver bullet for everything that the built-in methods can not do. Because it is a wrapper, it does not make any assumptions about the underlying data. Unlike the other methods, it does not take advantage of any vectorization but executes the statement row by row or column by column. On top of that, it consumes a ton of memory and returns a new pandas series, which also creates quite some IO overhead.</p><p>Should list comprehensions automatically be the new standard of data science, then? Not necessarily. First of all, it is essential to highlight that the combination with zip is doing the heavy lifting here. The python zip method is implemented so that it allows you to traverse iterators in parallel rather than instance per instance. In combination with a list comprehension, the function is thus applied in parallel, causing the impressive performance speedup. Although it is a clever trick, there are other alternatives to speed up the apply syntax. For instance, the built-in map method allows for parallelization and achieves the same performance increase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ut0ge23U-tm8gE8e.png" /></figure><p>Even though pandas — if used appropriately — is quite efficient, it still has some significant drawbacks in terms of performance. The three most important of them are its slowness concerning numerical computations, its scalability when working with massive datasets, and its lack of support for multiprocessing (e.g., pandas only uses 1 CPU).</p><p>Although it would fall outside the scope of this blog to discuss them all, numerous alternatives have been released over time. For example, dask, modin, koalas, polars, and recently, terality. All these packages try to resolve those issues while mostly keeping the pandas syntax unchanged. So, feel free to explore those libraries if all of the above tips are to no avail or you are still unsatisfied with the performance.</p><p>Even though the advantages of vectorization are undeniable, I don’t expect you to start rewriting all your inefficient functions immediately. With this blog post, I merely wanted to provide some tooltips which could help you identify potential bottlenecks in your code, some common pitfalls, and how you can solve those. Though it will often require some changes to the existing pipeline, it is usually well worth it in terms of potential performance increases. It was not my intention to provide countless examples of code optimizations. Rather, I wanted to introduce a new method of approaching repetitive tasks. As with everything within programming, though, practice makes perfect, and adapt these practices to a workflow you feel comfortable with.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db02b857b4d7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/brainjar/code-optimization-changing-the-way-you-approach-repetitive-tasks-db02b857b4d7">Code optimization: changing the way you approach repetitive tasks</a> was originally published in <a href="https://medium.com/brainjar">Brainjar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Code optimization: changing the way you approach repetitive tasks]]></title>
            <link>https://medium.com/raccoons-group/code-optimization-changing-the-way-you-approach-repetitive-tasks-69741ab2df60?source=rss-9bf89b54bad6------2</link>
            <guid isPermaLink="false">https://medium.com/p/69741ab2df60</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[brainjar]]></category>
            <dc:creator><![CDATA[Sam Hendrickx]]></dc:creator>
            <pubDate>Wed, 06 Jul 2022 11:42:24 GMT</pubDate>
            <atom:updated>2022-07-06T11:43:26.093Z</atom:updated>
            <content:encoded><![CDATA[<p>Imagine: you are working on a specific problem. After much trial and error, your code finally does what it is supposed to do. The solution is neither elegant nor very efficient, but you have already spent more time than you wanted to. You tell yourself you will refactor the code somewhere in the future. As time goes by, you obviously do not find any more time (or desire) to do so, and you leave your code as it was. After all, the code works, and you have much more important issues to deal with first. Sounds familiar?</p><p>Fast forward to the moment you are ready to put everything into production. You notice that a small part of the pipeline is remarkably slow. You dive into the code, and you identify the problem. Shock. It is the code you had written months ago that you told yourself you would refactor at some point. Well, that moment has finally arrived.</p><p>According to a famous ancient quote (originating in the 1960s) from Donald Knuth (“Premature optimization is the root of all evil”), this workflow is completely fine. The premise of that quote originates from the logic that programmers spend far too much time on things they may not need in the end. Examples include optimizing a preprocessing function that eventually does not make it to production. Another example is prematurely scaling to millions of users while you are still a scale-up and only have a couple of users.</p><p>In this blog post, I’m not going to tell you that Donald was completely wrong or that his reasoning is outdated. Instead, I mainly want to give you some do’s and don’ts pointers, how you can identify possible optimizations in your code, and how to optimize it.</p><h4><strong>The power of vectorization</strong></h4><p>First, I would like to introduce you to a very basic toy example. Assume we have an array of integers, and we would like to randomly sample an increase between 0 and 2 for each value in the array. We can solve this in various ways. I have outlined three of them with their corresponding computation times for various data lengths.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/954/0*IwbMA5n8M4Jl8fG0.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gzaxYV6NdUYWt-UE.png" /></figure><p>For this effortless task, we see that the classic for loop is a tad slower than the list comprehension. The difference comes from the additional overhead of appending. However, both are much slower than the ‘vectorized’ method, for which the effect increases as the data gets larger.</p><p>By only sampling once, we could eliminate significant overhead and take advantage of the numpy computations (which are implemented in C), which can be computed in parallel. Without going into too much detail, vectorization reduces the number of CPU instructions, memory reads, and cache misses. More recent versions of numpy also take advantage of parallelization with SIMD (Single Instructions Multiple Data). In essence, vectorization is transforming your code so that it can be automatically translated to machine code instead of the default slow python code.</p><p>Since vectorization works so well because it minimizes costly operations, I would like to introduce a concept I like to call ‘pseudo-vectorization’. Within pseudo-vectorization, you first identify the potential bottlenecks/costly operations in your code. Then, you try to reduce those by preprocessing/cleverly transforming your data. But how can we identify these potential bottlenecks in our code now? This is where line_profiler comes in.</p><h4><strong>Identifying and solving bottlenecks in your code</strong></h4><p><a href="https://pypi.org/project/line-profiler/">Line_profiler</a> is a convenient package showing the time individual code lines take to execute. It is straightforward to set up, and with a few lines of code, you get an incredibly insightful overview of the execution time of a particular function. The function from the image returns a slightly modified time series data frame for a day with 24 timesteps. It only needs to modify specific columns with randomly sampled nearest existing values, and certain values needed to remain constant (due to the nature of the scale of certain variables).</p><p>To reduce the computation time, the first step is to compute this information/metadata once and pass it to the function. Since this was a function that had to be applied tens of thousands of times, waiting times accumulated. I decided to have a look at it with line_profiler. The output was quite shocking. Rather than trying to optimize for lines within the function, it was the return line that took over 85% of the total computation time. The function we had written turned out to be quite efficient, but it was merely the final step of creating a data frame from an array and assigning the original columns that were so expensive. By simply returning the array, we sped up our code by a factor of almost 10.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qGJwJmtFJpibT-4v.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RqJl1s4276wLYzyj.png" /></figure><p>But Olivier, now our function returns an array instead of a data frame. That’s not what we want. Yes, I know, and that is what I was referring to during my introduction to pseudo-vectorization. You will often have to make slight but intelligent modifications to your pipeline to benefit from it. Instead of always returning a data frame, you should slightly adapt your code. This way, you only create a data frame once after concatenating all numpy arrays from our adapted function. With some minor changes in your code, that part of the pipeline is now 10 times faster.</p><p>You could go even further and vectorize the loops if you want, speeding up the function. However, vectorizing too much can sometimes be detrimental to your code’s readability, as observed from the image below, which does the same as the previous functions. As a rule of thumb, I wouldn’t start to maniacally vectorize everything if there is no real need. Nevertheless, it is an instrumental skill to have in your pocket.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NnL92WJLlCnIdSAJ.png" /></figure><p>Of course, it is not always as straightforward or easy as in this example. Identifying and fixing bottlenecks in your code is a learning experience. It is something you will get better at as time progresses. Especially vectorizing your code can be pretty challenging at first. The most impactful optimizations originate from processes that need to be repeated multiple times.</p><p>Another example from a real case study is calculating the feature importance for a time series classification problem. Since we couldn’t rely on an existing package due to the multi-output of the model and multivariate time series input, we had to write our implementation of the Shapley values. In that instance, I had written a method that calculated the feature importance case by case, rerunning the predictions with every case. Initially, this was fine, but as the project matured, this started to become a problem.</p><p>Eventually, I decided to rewrite the method. I identified that the main performance issues came from running the predictions so many times (we had hundreds of features, so for one case, we had to perform inference already close to a thousand times). I rewrote the code so we would only run the predictions once but with large batch size. Again, this required some changes to the pipeline (you had to keep track of some metadata and then eventually assign the concatenated predictions to that metadata). Still, the potential speedup (which I had first verified) was enormous, resulting in a method that was now 15–20x faster. Although optimizations are often in the form of a for loop or a list comprehension, this is not exclusively the case. Applying a custom function inefficiently multiple times can also cause severe troubles, which we will see in our next section.</p><h4><strong>Assessing the efficiency of pandas</strong></h4><p>Import pandas as pd is probably the number one used import of all data scientists and is perhaps on top of basically every one of your notebooks. And with good reason. It is convenient, user-friendly, and reasonably fast, right? But how efficient is the pandas library? And when should we use it?</p><p>Since pandas uses numpy under the hood, almost all of the build-in methods in pandas are fast. As opposed to numpy, they are specifically designed to work well with tabular data of different types (strings, integers, lists, etc.). It is also considered faster if you have more than 500k observations. The main drawbacks of the pandas library are that it consumes much more memory than numpy. Moreover, indexing is ridiculously slow, compared to numpy, which excels in both aspects. As a rule of thumb, I would suggest converting to numpy if you are solely working with numerical data, if you can not resort to the build-in pandas methods, or if you are considering using the pandas build-in method.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5Bgb4aJj8Z2TO59Y.png" /></figure><p>Imagine: you want to apply a custom function on multiple columns of your data frame for the first time. A quick google search later, you will probably have learned about <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.apply.html">pandas.DataFrame.apply</a>. You copy-paste one of the first answers on StackOverflow, tweak it to your data frame, and the code exactly does what you want it to do. It might be a bit slow, but hey, it was the top answer on that StackOverflow thread. Surely, there won’t be a better solution to this, right?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iW5Y_5tHf3nKRv9L.png" /></figure><p>Let’s put that to the test. As a proof of concept, I have created a toy function that scales the number of flights based on an airport-specific maximum value previously stored in a dictionary. It thus requires exactly two columns from the data frame. We will start by assessing the performance of the often recommended apply-syntax.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ib_duSk4Iy_A4KJk.png" /></figure><p>2.7 seconds for a little more than 20.000 observations. Not great, but reasonable. At first. Somewhere along my first project, I remember waiting almost half an hour for an apply function to finish on a data frame of a couple of million rows. I remember doing this a couple of times until I finally was fed up with it. I did what every programmer does in that situation: consult Google and look for better alternatives. One of the first suggestions I came across was using a list comprehension combined with zip. So, I took over the suggested syntax and started to wait. For merely 15 seconds. This alternative was over 100 times faster. How is that possible? And why does apply exist then?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2BOsEOEaXRgPqJnf.png" /></figure><p>Let’s look at our toy example. The situation above did not happen to be a lucky shot. Apply is indeed ridiculously slow. But why? Apply is a bit of a misfit within the pandas family. It is a wrapper/silver bullet for everything that the built-in methods can not do. Because it is a wrapper, it does not make any assumptions about the underlying data. Unlike the other methods, it does not take advantage of any vectorization but executes the statement row by row or column by column. On top of that, it consumes a ton of memory and returns a new pandas series, which also creates quite some IO overhead.</p><p>Should list comprehensions automatically be the new standard of data science, then? Not necessarily. First of all, it is essential to highlight that the combination with zip is doing the heavy lifting here. The python zip method is implemented so that it allows you to traverse iterators in parallel rather than instance per instance. In combination with a list comprehension, the function is thus applied in parallel, causing the impressive performance speedup. Although it is a clever trick, there are other alternatives to speed up the apply syntax. For instance, the built-in map method allows for parallelization and achieves the same performance increase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WLfKeW6tukRRhuMB.png" /></figure><p>Even though pandas — if used appropriately — is quite efficient, it still has some significant drawbacks in terms of performance. The three most important of them are its slowness concerning numerical computations, its scalability when working with massive datasets, and its lack of support for multiprocessing (e.g., pandas only uses 1 CPU).</p><p>Although it would fall outside the scope of this blog to discuss them all, numerous alternatives have been released over time. For example, dask, modin, koalas, polars, and recently, terality. All these packages try to resolve those issues while mostly keeping the pandas syntax unchanged. So, feel free to explore those libraries if all of the above tips are to no avail or you are still unsatisfied with the performance.</p><p>Even though the advantages of vectorization are undeniable, I don’t expect you to start rewriting all your inefficient functions immediately. With this blog post, I merely wanted to provide some tooltips which could help you identify potential bottlenecks in your code, some common pitfalls, and how you can solve those. Though it will often require some changes to the existing pipeline, it is usually well worth it in terms of potential performance increases. It was not my intention to provide countless examples of code optimizations. Rather, I wanted to introduce a new method of approaching repetitive tasks. As with everything within programming, though, practice makes perfect, and adapt these practices to a workflow you feel comfortable with.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=69741ab2df60" width="1" height="1" alt=""><hr><p><a href="https://medium.com/raccoons-group/code-optimization-changing-the-way-you-approach-repetitive-tasks-69741ab2df60">Code optimization: changing the way you approach repetitive tasks</a> was originally published in <a href="https://medium.com/raccoons-group">Raccoons Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My perspective on the retrospective]]></title>
            <link>https://medium.com/raccoons-group/my-perspective-on-the-retrospective-ea77edf08756?source=rss-9bf89b54bad6------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea77edf08756</guid>
            <category><![CDATA[retrospectives]]></category>
            <category><![CDATA[tpo-agency]]></category>
            <dc:creator><![CDATA[Sam Hendrickx]]></dc:creator>
            <pubDate>Tue, 05 Jul 2022 08:34:04 GMT</pubDate>
            <atom:updated>2022-07-05T08:35:07.737Z</atom:updated>
            <content:encoded><![CDATA[<p>To achieve a project or product team’s goals, you need a solid group of like-minded people to work together. Finding such a group of people is one thing; maintaining and improving their qualities is another. Luckily, agile development has the solution: a <strong>retrospective</strong>.</p><p>A retrospective is a defined reoccurring time to look back and evaluate what went well and what went (horribly) wrong during a project. Doing this correctly can create enormous value for the team’s efficiency and morale. Sadly, it has the opposite effect when done incorrectly. And, oh boy, there are a lot of pitfalls when it comes to retrospectives.</p><blockquote>The Sprint <strong>retrospective</strong> is an opportunity for the Scrum Team to inspect itself and create a plan for improvements to be enacted during the next Sprint. — <a href="http://scrum.org/">Scrum.org</a></blockquote><h4>Retrospective: key subjects</h4><p>A couple of critical subjects are essential when preparing for a retrospective meeting. To ensure these key subjects are integrated, you should answer three questions at the end of each retrospective.</p><ul><li>How can we improve efficiency?</li><li>How can we improve the team vibe?</li><li>How can we improve the personal morale of each team member?</li></ul><figure><img alt="retrospective key subjects" src="https://cdn-images-1.medium.com/max/1024/0*AZ0i_j8HhufUYfHW.png" /><figcaption>All subjects needed to create a perfect retrospective</figcaption></figure><p>In this blog, we will dive deeper into these three key subjects.</p><h4>Efficiency</h4><p>Efficiency might be the easiest subject to discuss during a retrospective. Simple questions like, what went wrong during our development process? What blocked us from going forward? And why did we have so much firefighting to do? Bring enough fuel to the table to talk about how the team can improve on working together.</p><p>If asking these questions doesn’t suffice, you must look for facts. Gather some insightful data to create a discussion. Examples are throughput numbers, burndown charts, ticket lifecycle information, or roadmap planning changes.</p><p>This subject becomes increasingly more difficult when the team becomes more mature. A mature team has fewer problems to deal with, so the focus, in this case, is to create minor iterative improvements in the development process. This way of working requires open-minded people and a lot of trial and error.</p><figure><img alt="retrospective problem solving" src="https://cdn-images-1.medium.com/max/1024/0*aGkE6ySHqXBI4Zmd.png" /><figcaption>The balance between problem-solving and improving based on team maturity</figcaption></figure><h4>Team vibe</h4><p>An excellent team vibe is fundamental. Intellectual capabilities have zero value when every team member hates each other. A team with high morale and motivation will perform better even if they lack experience and technical skills. Asking straight up what the mood is within the group might give you an unrealistic answer. Peer pressure plays a big part here.</p><p>An ideal way to counter this is to gather the data passively during the retrospective. Listening and observing are super valuable methods here. Something might be off if there’s low engagement during the retro or heated discussions arise every five minutes.</p><p>You could choose to act on it immediately, but this can lead to long, elaborate conversations. The better option is to acknowledge it and gather more information, do some root cause analysis, and plan a dedicated meeting to discuss the causes and potential solutions. Alternatively, you can let each team member rate the team vibe anonymously on a scale of 1–5.</p><h4>Individual morale</h4><p>Just like team vibe, individual morale is something crucial within a team. However, this is a delicate subject and should be treated with the most caution. If an individual feels bad within the group, it can start to create bottlenecks within the development process, and eventually, it will direct the whole team into a downwards spiral.</p><p>Like with the team vibe, listening to and observing the team’s behavior during the meeting can give you the necessary information. A closed rating system works well because individuals can open up without peer influence. Issues that arise here should always be handled behind closed doors. Avoiding embarrassment toward an individual should be one of your main concerns. Improving your interpersonal skills can benefit you in nailing this part of the retrospective.</p><h4>Facilitating a retrospective</h4><p>Knowing what you want to achieve from the retrospective meeting is one thing. Executing a meeting is an entirely different thing. Here are three crucial subjects to consider when facilitating a retrospective meeting:</p><ul><li>Make sure results are delivered and measured</li><li>Use tools to help you and the team through the retrospective meeting</li><li>Time management within the meeting</li></ul><figure><img alt="retrospective" src="https://cdn-images-1.medium.com/max/696/0*Ct9Dfihf_vAq9ghf.png" /><figcaption>Three subjects that help you facilitate a retrospective meeting</figcaption></figure><h4>Results</h4><p>The retrospective meeting is perfect for discovering problems or creating opportunities. Even more, it is a meeting with a high level of communication that impacts every team member. However, discovering is not enough.</p><p>Creating measurable actions based on the discussion is crucial to bringing positive change. The SMART Principle is handy when executing these actions. It feels a bit strange to create a SMART action based on the emotional feeling of a team/individual. This is understandable, but try and focus on the time-related, realistic, and measurable part. When your team can create these actionable items every retrospective, reviewing them is very interesting. This way, you can confirm that the issue has been resolved or that the improvement is successful.</p><h4>Tools</h4><p>Many tools are available for project/product development, from budget management to gathering user feedback. Retrospectives are no exception. Most retro tools focus on a ticket system. With this system, users can create tickets and sort them into various categories. These categories come in the standard form of “went well”, “went bad”, or “action items”.</p><p>There are even Harry Potter-themed retrospectives where you must choose one of the four houses. This customization mainly goes to entertaining and engaging the team, resulting in a more open and communicative retro. We’ll end this subject with a list of interesting tools for you.</p><ul><li>Easyretro</li><li>Miro</li><li>Basic post-it</li><li><a href="http://reetro.io/">Reetro.io</a></li></ul><h4>Time management</h4><p>This subject is not only relevant for retrospectives. Anytime you are preparing for a meeting, time management is something you should take into account. A retro should not take longer than 2 hours, and this ritual should have an uplifting effect when it is over since you are tackling and acknowledging problems.</p><p>If your retro takes more than 2 to 3 hours, it will have the opposite effect, no matter how great your meeting content is. You can do a couple of things to make the most out of the 2 hours:</p><ol><li>Let everyone in the meeting prepare their tickets before the session begins. This way, you don’t have to spend time waiting for people</li><li>Start by reviewing the actions listed during the last retro</li><li>Let everyone do a concise preview of their tickets</li><li>Use a dot voting system to rank the tickets. The dots decide the order in which the tickets will be handled</li><li>When discussing a topic, set a 5-minute timer. When the time is up, the group collectively decides if they want to spend another 5 minutes on the subject or go to the next issue. This is also an excellent time to give the more silent people a chance to speak</li><li>Make sure actionable items are noted after every topic</li></ol><h4>Nice to know/TL;DR</h4><p>The retrospective is a meeting to increase the morale and efficiency of the team and its individuals. If you have to choose, this is the meeting you should do live instead of through a video call, given the personal aspect of the meeting.</p><p>A truckload of tools and templates will help you structure your retrospective meeting and make it more engaging for your team. Another way to increase engagement is to let one of your team members facilitate the discussion. Finally, to finish the retrospective well, try to keep it within two hours not to wear out your team, as this is the opposite of what you want to achieve.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea77edf08756" width="1" height="1" alt=""><hr><p><a href="https://medium.com/raccoons-group/my-perspective-on-the-retrospective-ea77edf08756">My perspective on the retrospective</a> was originally published in <a href="https://medium.com/raccoons-group">Raccoons Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[‘Bubble Jump’ — Building an augmented reality game during my internship]]></title>
            <link>https://medium.com/raccoons-group/bubble-jump-building-an-augmented-reality-game-during-my-internship-baff16991abf?source=rss-9bf89b54bad6------2</link>
            <guid isPermaLink="false">https://medium.com/p/baff16991abf</guid>
            <category><![CDATA[augmented-reality]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[internships]]></category>
            <dc:creator><![CDATA[Sam Hendrickx]]></dc:creator>
            <pubDate>Thu, 16 Jun 2022 15:00:06 GMT</pubDate>
            <atom:updated>2022-06-16T15:01:07.187Z</atom:updated>
            <content:encoded><![CDATA[<h4>Taking a detour — Machine learning internship</h4><p>As a third-year student in Applied Informatics at UCLL, I started looking for an internship early in the year. At the start of my pursuit of a relevant internship, I quickly distilled all the options to the four most interesting ones. One of them was a project at Brainjar, a venture of Raccoons specialized in artificial intelligence.</p><p>The objective was to create an application that turns photos into paintings. During my job interview, I discovered that I slightly mistook the project for an augmented reality application while it actually was a machine learning application. Nevertheless, this project was still the most attractive option, so I decided to take on the challenge, knowing I had no prior experience with machine learning.</p><p>Luckily, my mentors were open to teaching me the ways of machine learning. I, however, quickly realized that machine learning, while very useful and interesting, is very different from the classical programming I liked and was used to. Thus, after three weeks, I went on a different path and continued my internship on a Craftworkz project — another organization within the Raccoons ecosystem. I am grateful Raccoons allowed me to work with them and later anticipated my interests by offering a different project.</p><h4>Take two — Augmented reality internship</h4><p>The second project was right up my alley: creating an augmented reality game. The purpose of this game was to enable a player to jump around a (physical) soda can from one platform to another. When one of these platforms is in the range of the player, it should light up. If the player then lands on them, they should react. Of course, these platforms need to be reachable from the previous block.</p><figure><img alt="internship - bubble jump" src="https://cdn-images-1.medium.com/max/966/0*NWb1v2gnOav9bRFj.jpg" /><figcaption>Bubble Jump — The game</figcaption></figure><p>In addition, to make it a real game, there should be scores, lives, and power-ups. One of these power-ups should propel the player upwards, so we called it Bubble Jump. Since a game should have sound, particle effects, and even vibrations on specific actions, I had some work to do.</p><p>Initially, this project was supposed to be a one-person internship by Jannes De Koning, a Multimedia &amp; Creative Technologies student. As I started later in the semester, Jannes had already done much research and was just about to refactor his code. This head start allowed us to go more in-depth into the project. This way, I quickly learned what the goals were, what technologies were being used, and why he made certain decisions. Because of this, I quickly learned all about the project and was able to contribute to it very quickly.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F6dtOPHb9CO0%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D6dtOPHb9CO0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F6dtOPHb9CO0%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2559915eaee3c535311c4e641c78e834/href">https://medium.com/media/2559915eaee3c535311c4e641c78e834/href</a></iframe><p>This blog will give you an overview of all the decisions made along the way, technical advances, and the result.</p><h4>Week 1–2: Image tracking</h4><h4>Getting started</h4><p>We jumped in and started by dividing the tasks according to our strengths. We decided that I would be responsible for the technical aspects and that Jannes would handle the graphical aspects of the project. We made this decision because Jannes has a graphics-oriented background while I have a technical one.</p><p>In addition, we decided to design a rough architecture and divide the project into prioritized issues. We then grouped these issues into deadlines. Since Jannes’ internship would end six weeks before mine, we split the project into two versions:</p><ol><li>A version without a back-end and thus no ability to store data, but with the complete gameplay implemented</li><li>An extension with a back-end and the ability to store data</li></ol><p>The game’s objective was to scan a physical can and use the actual can to play the game ‘on’. To do this, we decided to use image tracking, which we could quickly do with 8th Wall. We encountered one issue, though, because when you begin scanning, you cannot open the application on a PC. Moreover, the application would not run well on Jannes’ smartphone, so we decided to implement the ‘can-scan’ feature at the end of Jannes’ internship.</p><h4>Bugs, bugs, bugs</h4><p>Our supervisors, however, asked us to move up the deadline of this feature as it is an essential part of the game, so we needed to find a way to implement it as quickly as possible. During the second week of our collaboration, we started the implementation, which ended up being more difficult than expected because of an unforeseen effect of the platforms.</p><p>Let us explain the unexpected effect in question. Our game detects when a player touches a platform with a collision box; however, this does not scale if the platform is scaled indirectly. As the level was scaled to the image of the can, it caused the platforms to be incorrect. Eventually, we fixed this by generating the level after the image was found.</p><p>Another problem we encountered was that the material we used to hide the platforms behind the physical can only worked on elements rendered at a later stage. 8th Wall did not describe this problem in their documentation; we only figured it out after testing.</p><p>In the first part of the project, we implemented Bubble Jump, lives, and timing elements — all visible in the following video. As you can see in the video, the Bubble Jump was not ideal and only worked fully when the frame rate stayed consistent. We fixed this later on in the project.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F70CsA-_4ITo%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D70CsA-_4ITo&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F70CsA-_4ITo%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2267b010832ef783e6a6b8e1a2f9de36/href">https://medium.com/media/2267b010832ef783e6a6b8e1a2f9de36/href</a></iframe><h4>Week 3: User interface</h4><p>Up next: the graphic part of the assignment. Jannes started on the 3D model and animation of the character, but unfortunately, he fell ill for three days, which meant the deadline moved up a few days. Luckily, we set up our collaboration so that this did not impact my ability to work. I was able to implement a couple more fixes:</p><ul><li>Win conditions</li><li>Functional UI (user interface)</li><li>Fix the wiggle of the level when tracking images</li></ul><p>As you can see in the following video, the UI is functional but not very intuitive nor pretty. However, this was not the point of this specific implementation of the UI, as we simply wanted a usable UI for testing the functions. Later on, we would completely redo the UI.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FCJiGNyhapyI%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DCJiGNyhapyI&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FCJiGNyhapyI%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2fb2904ca8ad541a2bbfa8253bc05418/href">https://medium.com/media/2fb2904ca8ad541a2bbfa8253bc05418/href</a></iframe><h4>Week 4: 3D models and animations</h4><p>This week was all about the player character and animations! Or at least, while Jannes was busy making assets for the game, I tried to project the player’s score on the can. However, it was not readable (as seen in the following video), so we decided that the previous UI was better. In addition, I added sound to the game and fixed some bugs.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fys8Cq6lm7uw%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dys8Cq6lm7uw&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fys8Cq6lm7uw%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/854df5a7f025e392c185563bfb3b5cb5/href">https://medium.com/media/854df5a7f025e392c185563bfb3b5cb5/href</a></iframe><h4>Week 5: Finishing v1</h4><p>As this was Jannes’ last week, we decided to focus on finishing version 1 and preparing for the internal presentation as a dry run for Jannes’ finals presentation. Finishing v1 entails that I prevented the player from falling through the platforms, making the game much more playable. Initially, I planned to do this the week before but ended up working on it a little longer. I also added particles to the game and connected the level generation with the physics making the Bubble Jump much more reliable. Jannes added some more assets. For example, he created an opening animation where the player walks out of the can at the start of the game. All of this you can see in the following video.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FdNv-ZYcXCvE%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DdNv-ZYcXCvE&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FdNv-ZYcXCvE%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/6d4983830cda6a9463c8e90c71301f3c/href">https://medium.com/media/6d4983830cda6a9463c8e90c71301f3c/href</a></iframe><h4>Week 6–8: Back-end creation &amp; UI touchups</h4><h4>Back-end</h4><p>In week six, I was once again working alone. Because we finished version 1 and most of the major gameplay features that do not depend on storing data, I started creating the backend. I chose the Express framework with a MySQL database to make the backend as I already have some experience with both these technologies. I started this by determining what the backend needed to do:</p><ul><li>New users should be able to be created</li><li>A user should be able to log in and out</li><li>A user should be able to save their high score per level mode</li><li>A user should be able to buy and use skins</li></ul><p>After deciding on the backend calls, I started designing the database. Once the database was created, I started implementing everything. The backend implementation posed no problems. The integration with the game, however, caused some issues.</p><p>As 8th Wall hosted the game and used an HTTPS connection, and I hosted my backend locally and used an HTTP connection, modern browsers did not allow my backend to set cookies on the game website for security reasons. This issue would not be a problem in production because the backend would also use an HTTPS connection. Thankfully, Firefox allows you to disable this security feature.</p><h4>Revisiting the UI</h4><p>Once I integrated the backend with the game, my supervisor asked me to focus on reworking the UI. I started by creating some wireframes to see how I wanted the UI to look. When I finished wireframing, I implemented the design. By the end of the week, I developed an option to show the player’s predicted jump path. In addition, the jump strength is now visible to the user.</p><p>You can see the improved UI in the video below. I am thrilled that I found the model-viewer web component, which allows the 3D models to be shown in the UI. This way, I can animate the model in the UI instead of only showing a still image of the skin when selecting one. The UI is also a lot more intuitive and prettier.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Ftux-fSsmg78%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dtux-fSsmg78&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Ftux-fSsmg78%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/dd869b422c1f64575091a78dc9528cee/href">https://medium.com/media/dd869b422c1f64575091a78dc9528cee/href</a></iframe><h4>Week 9–10: Documentation</h4><p>In the final weeks of my internship, I mostly wrote documentation and fixed some minor bugs. The result of this you can find <a href="https://craftworkz.8thwall.app/can-jumper/">here</a>. Unfortunately, this is a demo project; thus, at the time of writing, you’ll only be able to use guest mode since we will not host the backend permanently.</p><h4>Looking back at the internship</h4><p>I am very thankful for this opportunity. So I would like to thank Raccoons once again. I found my time working for them a lot of fun. Their work environment is open but professional, and their employees are very friendly and approachable. I would recommend an internship at Raccoons.</p><p>The second project turned out even better than my expectations. The collaboration with Jannes turned out to be an absolutely positive experience for both the project and my internship. I believe the results would be completely different and inferior if either of us would have worked on this project alone.</p><p>Finally, I would like to thank you for reading this blog. I hope you enjoy playing the game, and I would love to hear about your experience and high scores.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=baff16991abf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/raccoons-group/bubble-jump-building-an-augmented-reality-game-during-my-internship-baff16991abf">‘Bubble Jump’ — Building an augmented reality game during my internship</a> was originally published in <a href="https://medium.com/raccoons-group">Raccoons Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[‘Bubble Jump’ — Building an augmented reality game during my internship]]></title>
            <link>https://medium.com/craftworkz/bubble-jump-building-an-augmented-reality-game-during-my-internship-ba3abea8f226?source=rss-9bf89b54bad6------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba3abea8f226</guid>
            <category><![CDATA[augmented-reality]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[internships]]></category>
            <dc:creator><![CDATA[Sam Hendrickx]]></dc:creator>
            <pubDate>Thu, 16 Jun 2022 14:49:22 GMT</pubDate>
            <atom:updated>2022-06-16T14:50:25.817Z</atom:updated>
            <content:encoded><![CDATA[<h4>Taking a detour — Machine learning internship</h4><p>As a third-year student in Applied Informatics at UCLL, I started looking for an internship early in the year. At the start of my pursuit of a relevant internship, I quickly distilled all the options to the four most interesting ones. One of them was a project at Brainjar, a venture of Raccoons specialized in artificial intelligence.</p><p>The objective was to create an application that turns photos into paintings. During my job interview, I discovered that I slightly mistook the project for an augmented reality application while it actually was a machine learning application. Nevertheless, this project was still the most attractive option, so I decided to take on the challenge, knowing I had no prior experience with machine learning.</p><p>Luckily, my mentors were open to teaching me the ways of machine learning. I, however, quickly realized that machine learning, while very useful and interesting, is very different from the classical programming I liked and was used to. Thus, after three weeks, I went on a different path and continued my internship on a Craftworkz project — another organization within the Raccoons ecosystem. I am grateful Raccoons allowed me to work with them and later anticipated my interests by offering a different project.</p><h4>Take two — Augmented reality internship</h4><p>The second project was right up my alley: creating an augmented reality game. The purpose of this game was to enable a player to jump around a (physical) soda can from one platform to another. When one of these platforms is in the range of the player, it should light up. If the player then lands on them, they should react. Of course, these platforms need to be reachable from the previous block.</p><figure><img alt="internship - bubble jump" src="https://cdn-images-1.medium.com/max/966/0*HLKFPR-iOrbXwTS5.jpg" /><figcaption>Bubble Jump — The game</figcaption></figure><p>In addition, to make it a real game, there should be scores, lives, and power-ups. One of these power-ups should propel the player upwards, so we called it Bubble Jump. Since a game should have sound, particle effects, and even vibrations on specific actions, I had some work to do.</p><p>Initially, this project was supposed to be a one-person internship by Jannes De Koning, a Multimedia &amp; Creative Technologies student. As I started later in the semester, Jannes had already done much research and was just about to refactor his code. This head start allowed us to go more in-depth into the project. This way, I quickly learned what the goals were, what technologies were being used, and why he made certain decisions. Because of this, I quickly learned all about the project and was able to contribute to it very quickly.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F6dtOPHb9CO0%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D6dtOPHb9CO0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F6dtOPHb9CO0%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2559915eaee3c535311c4e641c78e834/href">https://medium.com/media/2559915eaee3c535311c4e641c78e834/href</a></iframe><p>This blog will give you an overview of all the decisions made along the way, technical advances, and the result.</p><h4>Week 1–2: Image tracking</h4><h4>Getting started</h4><p>We jumped in and started by dividing the tasks according to our strengths. We decided that I would be responsible for the technical aspects and that Jannes would handle the graphical aspects of the project. We made this decision because Jannes has a graphics-oriented background while I have a technical one.</p><p>In addition, we decided to design a rough architecture and divide the project into prioritized issues. We then grouped these issues into deadlines. Since Jannes’ internship would end six weeks before mine, we split the project into two versions:</p><ol><li>A version without a back-end and thus no ability to store data, but with the complete gameplay implemented</li><li>An extension with a back-end and the ability to store data</li></ol><p>The game’s objective was to scan a physical can and use the actual can to play the game ‘on’. To do this, we decided to use image tracking, which we could quickly do with 8th Wall. We encountered one issue, though, because when you begin scanning, you cannot open the application on a PC. Moreover, the application would not run well on Jannes’ smartphone, so we decided to implement the ‘can-scan’ feature at the end of Jannes’ internship.</p><h4>Bugs, bugs, bugs</h4><p>Our supervisors, however, asked us to move up the deadline of this feature as it is an essential part of the game, so we needed to find a way to implement it as quickly as possible. During the second week of our collaboration, we started the implementation, which ended up being more difficult than expected because of an unforeseen effect of the platforms.</p><p>Let us explain the unexpected effect in question. Our game detects when a player touches a platform with a collision box; however, this does not scale if the platform is scaled indirectly. As the level was scaled to the image of the can, it caused the platforms to be incorrect. Eventually, we fixed this by generating the level after the image was found.</p><p>Another problem we encountered was that the material we used to hide the platforms behind the physical can only worked on elements rendered at a later stage. 8th Wall did not describe this problem in their documentation; we only figured it out after testing.</p><p>In the first part of the project, we implemented Bubble Jump, lives, and timing elements — all visible in the following video. As you can see in the video, the Bubble Jump was not ideal and only worked fully when the frame rate stayed consistent. We fixed this later on in the project.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F70CsA-_4ITo%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D70CsA-_4ITo&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F70CsA-_4ITo%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2267b010832ef783e6a6b8e1a2f9de36/href">https://medium.com/media/2267b010832ef783e6a6b8e1a2f9de36/href</a></iframe><h4>Week 3: User interface</h4><p>Up next: the graphic part of the assignment. Jannes started on the 3D model and animation of the character, but unfortunately, he fell ill for three days, which meant the deadline moved up a few days. Luckily, we set up our collaboration so that this did not impact my ability to work. I was able to implement a couple more fixes:</p><ul><li>Win conditions</li><li>Functional UI (user interface)</li><li>Fix the wiggle of the level when tracking images</li></ul><p>As you can see in the following video, the UI is functional but not very intuitive nor pretty. However, this was not the point of this specific implementation of the UI, as we simply wanted a usable UI for testing the functions. Later on, we would completely redo the UI.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FCJiGNyhapyI%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DCJiGNyhapyI&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FCJiGNyhapyI%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2fb2904ca8ad541a2bbfa8253bc05418/href">https://medium.com/media/2fb2904ca8ad541a2bbfa8253bc05418/href</a></iframe><h4>Week 4: 3D models and animations</h4><p>This week was all about the player character and animations! Or at least, while Jannes was busy making assets for the game, I tried to project the player’s score on the can. However, it was not readable (as seen in the following video), so we decided that the previous UI was better. In addition, I added sound to the game and fixed some bugs.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fys8Cq6lm7uw%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dys8Cq6lm7uw&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fys8Cq6lm7uw%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/854df5a7f025e392c185563bfb3b5cb5/href">https://medium.com/media/854df5a7f025e392c185563bfb3b5cb5/href</a></iframe><h4>Week 5: Finishing v1</h4><p>As this was Jannes’ last week, we decided to focus on finishing version 1 and preparing for the internal presentation as a dry run for Jannes’ finals presentation. Finishing v1 entails that I prevented the player from falling through the platforms, making the game much more playable. Initially, I planned to do this the week before but ended up working on it a little longer. I also added particles to the game and connected the level generation with the physics making the Bubble Jump much more reliable. Jannes added some more assets. For example, he created an opening animation where the player walks out of the can at the start of the game. All of this you can see in the following video.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FdNv-ZYcXCvE%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DdNv-ZYcXCvE&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FdNv-ZYcXCvE%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/6d4983830cda6a9463c8e90c71301f3c/href">https://medium.com/media/6d4983830cda6a9463c8e90c71301f3c/href</a></iframe><h4>Week 6–8: Back-end creation &amp; UI touchups</h4><h4>Back-end</h4><p>In week six, I was once again working alone. Because we finished version 1 and most of the major gameplay features that do not depend on storing data, I started creating the backend. I chose the Express framework with a MySQL database to make the backend as I already have some experience with both these technologies. I started this by determining what the backend needed to do:</p><ul><li>New users should be able to be created</li><li>A user should be able to log in and out</li><li>A user should be able to save their high score per level mode</li><li>A user should be able to buy and use skins</li></ul><p>After deciding on the backend calls, I started designing the database. Once the database was created, I started implementing everything. The backend implementation posed no problems. The integration with the game, however, caused some issues.</p><p>As 8th Wall hosted the game and used an HTTPS connection, and I hosted my backend locally and used an HTTP connection, modern browsers did not allow my backend to set cookies on the game website for security reasons. This issue would not be a problem in production because the backend would also use an HTTPS connection. Thankfully, Firefox allows you to disable this security feature.</p><h4>Revisiting the UI</h4><p>Once I integrated the backend with the game, my supervisor asked me to focus on reworking the UI. I started by creating some wireframes to see how I wanted the UI to look. When I finished wireframing, I implemented the design. By the end of the week, I developed an option to show the player’s predicted jump path. In addition, the jump strength is now visible to the user.</p><p>You can see the improved UI in the video below. I am thrilled that I found the model-viewer web component, which allows the 3D models to be shown in the UI. This way, I can animate the model in the UI instead of only showing a still image of the skin when selecting one. The UI is also a lot more intuitive and prettier.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Ftux-fSsmg78%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dtux-fSsmg78&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Ftux-fSsmg78%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/dd869b422c1f64575091a78dc9528cee/href">https://medium.com/media/dd869b422c1f64575091a78dc9528cee/href</a></iframe><h4>Week 9–10: Documentation</h4><p>In the final weeks of my internship, I mostly wrote documentation and fixed some minor bugs. The result of this you can find <a href="https://craftworkz.8thwall.app/can-jumper/">here</a>. Unfortunately, this is a demo project; thus, at the time of writing, you’ll only be able to use guest mode since we will not host the backend permanently.</p><h4>Looking back at the internship</h4><p>I am very thankful for this opportunity. So I would like to thank Raccoons once again. I found my time working for them a lot of fun. Their work environment is open but professional, and their employees are very friendly and approachable. I would recommend an internship at Raccoons.</p><p>The second project turned out even better than my expectations. The collaboration with Jannes turned out to be an absolutely positive experience for both the project and my internship. I believe the results would be completely different and inferior if either of us would have worked on this project alone.</p><p>Finally, I would like to thank you for reading this blog. I hope you enjoy playing the game, and I would love to hear about your experience and high scores.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba3abea8f226" width="1" height="1" alt=""><hr><p><a href="https://medium.com/craftworkz/bubble-jump-building-an-augmented-reality-game-during-my-internship-ba3abea8f226">‘Bubble Jump’ — Building an augmented reality game during my internship</a> was originally published in <a href="https://medium.com/craftworkz">Craftworkz</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why outlines are essential (and how to use them correctly) — CSS]]></title>
            <link>https://medium.com/raccoons-group/why-outlines-are-essential-and-how-to-use-them-correctly-css-b583ab986759?source=rss-9bf89b54bad6------2</link>
            <guid isPermaLink="false">https://medium.com/p/b583ab986759</guid>
            <category><![CDATA[immersive-technology]]></category>
            <category><![CDATA[wheelhouse]]></category>
            <dc:creator><![CDATA[Sam Hendrickx]]></dc:creator>
            <pubDate>Mon, 13 Jun 2022 15:25:44 GMT</pubDate>
            <atom:updated>2022-06-13T15:26:45.600Z</atom:updated>
            <content:encoded><![CDATA[<p>If you only have used the attribute outlines in CSS to disable them, you need to continue reading this blog on using outlines correctly!</p><p>We want to use an outline to visualize when an item is focused. This focused state is triggered when clicking on an item or using the tab key on your keyboard. Of course, you can visualize it how you want, but generally speaking, you would use an outline.</p><h4>Outlines for accessibility</h4><p>As I said earlier, you don’t need an outline when navigating through the page with clicks or taps. As we don’t use our keyboards, we often forget how vital an outline is. But when you only use your keyboard, you will need a visual cue to know where you are on the website.</p><p>With CSS, you can easily set an outline when focused, but what’s the difference between focus and focus-visible?</p><figure><img alt="Outlines CSS" src="https://cdn-images-1.medium.com/max/1024/0*gBF849SKHOPhFgPQ.gif" /><figcaption>use the tab key to show where you are on the webpage</figcaption></figure><h4>:focus vs. :focus-visible</h4><p>What’s the difference between :focus and :focus-visible, and which should you use? Let me explain. When using <strong>:focus</strong>, the outlines (like I show in the image above) would also show when we physically click on a button, which is not always the desired effect. So, if you want the outline to show when using the keyboard to navigate but don’t want it to show when physically clicking on it, we use <strong>:focus-visible</strong>.</p><p>Because not all browsers support focus-visible, we still need to use both (confusing, right). But when the browser supports focus-visible, we want to remove the outline on the :focus class.</p><p>This is how it’s done:</p><pre>:focus-visible, :focus {<br><br>box-shadow: none;<br><br>outline: 3px solid rgba(88,189,133,.65);<br><br>outline-offset: 2px;<br><br>}<br><br>*:focus:not(:focus-visible) {<br>  outline: none;<br>}</pre><h4>TL;DR</h4><p>An outline is vital for making your web application accessible to users who only use their keyboards. Using the pseudo-class :focus-visible is exactly what you should use because the outline will only show up when using the tab key on your keyboard. Sadly, not all browsers support :focus-visible, which is why we still need to use :focus as well.</p><p>It’s a straightforward and clean solution that can help many users who want to use your website. So, think about this blog before disabling the outline in your next project!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b583ab986759" width="1" height="1" alt=""><hr><p><a href="https://medium.com/raccoons-group/why-outlines-are-essential-and-how-to-use-them-correctly-css-b583ab986759">Why outlines are essential (and how to use them correctly) — CSS</a> was originally published in <a href="https://medium.com/raccoons-group">Raccoons Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>