Tydy is building the world's most comprehensive \u0026 automated onboarding platform

Tydy

tydy

Totally Nerdy founder Patrick Pittich-Rinnerthaler joins us in this AMA to talk about his API technology tyny.dev. Slogging tyny.dev is an API technology that makes building a custom API easy, without the need for coding skills. You can find out more about the software . here This Slogging thread by Jack Boreham, ex_pat_pat, Abeer, Mónica Freitas, Limarc Ambalina and SuperSaiyanProgramming occurred in slogging's official #amas channel, and has been edited for readability. Jack Boreham Jan 27, 2022, 12:00 PM Hey @channel, please join me in welcoming our next AMA guest, ex_pat_pat the founder of Totally Nerdy, a software company based in the UK. Totally Nerdy are the creators of a JSON API software that allows you to build a custom JSON API in minutes without coding skills. Please feel free to ask Patrick anything about: http://tyny.dev What a JSON API is Why he created and what it does http://tyny.dev What the life of a software developer looks like Startup businesses Anything technology related! Jack Boreham Jan 27, 2022, 12:02 PM Hi ex_pat_pat, a pleasure to have you with us. Can you explain a bit about yourself and your background to start off this AMA? ex_pat_pat Jan 27, 2022, 12:03 PM Jack Boreham Hi Jack, thanks a lot, likewise! I’m happy to ex_pat_pat Jan 27, 2022, 12:09 PM Where to start, let’s see: I’m a tech guy, first of all, working on different things all the time. Interested in various tech topics from Gaming over Smart Home to web technologies, embedded devices and all that stuff. As Jack mentioned I’m the Managing Director of a UK based Software Company mainly doing web and app stuff. Besides that, I’m very fresh in the startup biz with our new product . This whole career I started almost 20 years ago. http://tyny.dev ex_pat_pat Jan 27, 2022, 12:12 PM I was born and raised in Germany and my beautiful family and I just recently moved to the country we love, which is the UK. Jack Boreham Jan 27, 2022, 12:14 PM ex_pat_pat So what made you create a startup? After all that experience, it's definitely not an easy thing to do! ex_pat_pat Jan 27, 2022, 12:19 PM Jack Boreham It’s quite the opposite I’d like to say, all the experience of 20 years of software development especially for the web made me create the startup in the first place. Because we saw a gap in the market which we try to fill with . http://tyny.dev Jack Boreham Jan 27, 2022, 12:34 PM ex_pat_pat that's interesting, so what gap did you see? How did you come about finding it? ex_pat_pat Jan 27, 2022, 1:07 PM Jack Boreham To explain “the gap” a bit more, I’d like to talk about how software architectures in the modern web are structured, just briefly. Because to understand what does and why it fills this gap you simply need this background knowledge. Bear with me, I try to make it as “non-technical” as possible. http://tyny.dev Starting on the user side of things, you normally interact with some kind of client, a browser, an app, or a desktop application - the Frontend. These clients talk to interfaces that hold your business logic, the code which does something for various use cases - the Backend. On the web, we talk about APIs. Application Programming Interfaces. But it’s not a web thing only. When you now start the process of developing an app, for example, you think about all those different components you’d need to finish your product, a nice looking frontend, APIs to handle your use cases, a database to store information….and off you go, the development begins. But what you don’t might consider from the start is how is your product going to evolve, what are things which might change in the future. And what are the things which a Product Owner (a non-technical person) might like to change without writing code? That’s one thing which does focus on - controllability of your product going forward….in the most standardised way there is, which is in form of a JSON API. http://tyny.dev ex_pat_pat Jan 27, 2022, 1:25 PM Jack Boreham…because of the fact that we couldn’t find a product out there which fosters this idea. There are big players out there that offer you an API as a service for your headless CMS but this approach targets different use cases, like structure data which you need to store all of your data. In the case of Hackernoon, these might be the articles, accounts, etc. not so much unstructured data to control certain things. And then on the other hand you can speak to your developers and write everything from scratch which does make sense a lot of the time but not always. Therefore gives you an affordable option to have that API for unstructured data together with an easy to understand WYSIWYG editor out of the box. http://tyny.dev ex_pat_pat Jan 27, 2022, 1:28 PM Jack Boreham The answer to how we found this gap is up there as well. Way too often did we join projects where only the final product was in focus, not so much the Evolution of it. And you re-iterate and re-iterate and lose a lot of money. Another aspect can be that you might not really know yet if your product is going to fly, so therefore reducing costs and time for developing your product is worth it. Abeer Jan 27, 2022, 3:17 PM Hey Patrick. It’s great to have you here. I’m curious, as a software developer, how did your day to day life look and how did it change after starting tyny.dev? ex_pat_pat Jan 27, 2022, 3:28 PM Abeer Hi there and thanks for your question. Great one. I’m still hands-on developing day today. You see. has just started off and 100% of my time is still working as an Architect/Developer/Consultant for clients of Totally Nerdy Ltd. To make the money I need 😉 It’s as practical as that. http://tyny.dev So the other 30% of my time (yes, you calculated correctly, it’s more than 100% ;)) I spend building the company and the product. It’s like being a jack of all trades from time to time, writing code, thinking about the system architecture, answering questions about MongoDB (I do consultancy work related to that database), thinking about the content we should write next for , and working on marketing strategies. I’m literally done in the evenings! 🙂 http://tyny.dev ex_pat_pat Jan 27, 2022, 3:30 PM But I love those different aspects I must admit. And I couldn’t spend one day without coding myself 😉 Jack Boreham Jan 27, 2022, 4:28 PM ex_pat_pat thank you for the insightful and in detail answers. So you talked about tyny.dev use cases and how it can be used for unstructured data. What other use cases make it stand out from the crowd? ex_pat_pat Jan 27, 2022, 5:48 PM Jack Boreham Thank you. Its biggest selling point is probably the WYSIWYG (what you see is what you get) editor for JSON together with the API that ships it. This enables non-technical people to work with JSON and manipulate it in an easy way. Due to the abstract nature of JSON, the use cases are rather endless but we picked four of them which we actively use to explain the product: Defining and controlling user interfaces Storing and serving static unstructured data like textual contents Rapid prototyping, if you just need an API to ship whatever data into your product fast….or as a first MVP Domain-specific languages, this is a rather huge and abstract case and concludes the others in a way. Just use a more practical example which would be form generation, see https://rjsf-team.github.io/react-jsonschema-form/ In summary, what makes it stand out from the crowd today is that it concentrates on the above things which are based on programming paradigms and development processes rather than being your go-to-tool for building a whole product without code. Mónica Freitas Jan 27, 2022, 9:07 PM Hi ex_pat_pat! What would you say are the main challenges you face in growing your company? ex_pat_pat Jan 27, 2022, 9:44 PM Hi Mónica Freitas, thanks for your question. That’s a really good one. For us at the moment I would say it’s finding the right balance between paid agency work for funding growth employee-wise and the investment we do for our product. Jack Boreham Jan 28, 2022, 9:51 AM ex_pat_pat so are you saying anyone could pick up tyny and use it. No developers needed at all? 😁 ex_pat_pat Jan 28, 2022, 11:14 AM Jack Boreham In general ‘yes’, but you would need to have a product to integrate it with. Whether this product was created with another low-code/no-code platform (without developers) or written from scratch by developers doesn’t matter. Mónica Freitas Jan 28, 2022, 11:32 AM ex_pat_pat, how would you like your company to grow? What's next for Totally Nerdy? ex_pat_pat Jan 28, 2022, 11:43 AM Mónica Freitas first of all I like to grow it in the most organic way possible, which means without external investments and so on. After that I’m aiming to grow it in every direction, which means doing what we’ve always done, delivering solutions to clients, joining projects where our help was demanded and selling our product to people who need it. Therefore Totally Nerdy is potentially very interesting for young talents because we have it all, agency work and a product that we constantly drive forward. Who knows maybe we will become a company focused and evolving around one product in the future only but for now it’s “the best of two worlds”. 🔥 1 Limarc Ambalina Jan 28, 2022, 12:05 PM Hey, ex_pat_pat have you ever tried Skyrim on Alexa? If so, what do you think about it? 😄 ex_pat_pat Jan 28, 2022, 12:08 PM Hi, Limarc Ambalina you’re speaking about Skyrim the Elder Scrolls game? On Alexa?! What does that look like? SuperSaiyanProgramming Jan 28, 2022, 12:07 PM Hey aside from HackerNoon, what are some places, forums, social networks where you posted about your startup to get the word out? ex_pat_pat Jan 28, 2022, 12:10 PM Hey, SuperSaiyanProgramming we’re present in a few of the popular channels like LinkedIn, Google My Business and Twitter. Mónica Freitas Jan 28, 2022, 12:20 PM ex_pat_pat Totally Nerdy is great for new talents. All recent grads want is an opportunity to jump into the job market. As we're on the subject, what type of talents do you feel your company needs the most at the moment? ex_pat_pat Jan 28, 2022, 12:25 PM Mónica Freitas In general, I think we’re going to look for talent all over the board during this upcoming year, from Marketing over Community Manager to Full-Stack Developers. But at the moment we’re going to look at Full-Stack-Developers only to scale our workloads. Jack Boreham Jan 28, 2022, 12:36 PM ex_pat_pat So you have mentioned future hires, but what does the next year look like for what milestones do you want to reach? http://tyny.dev ex_pat_pat Jan 28, 2022, 12:47 PM Jack Boreham I’d like to reach a point where the product does carry itself, which of course means more paying users. This on the other hand will give us more funds for developing the product further. We do have lots more in store for feature-wise. http://tyny.dev ex_pat_pat Jan 28, 2022, 12:55 PM In directly related to the product, I’d like all Product Owners out there to understand the reason behind it: controllability of code. And how this helps future iterations. Which is an approach I’m happy to illustrate and discuss with clients, even if they don’t want to use because they like to implement such a solution themselves. http://tyny.dev Limarc Ambalina Jan 28, 2022, 3:30 PM Yeah ex_pat_pat you mentioned "Gaming over Smart Home" and that was the only smart device game I knew of. It's like this: But not as dramatic lol. It's a real game ex_pat_pat Jan 28, 2022, 3:49 PM Limarc Ambalina Oh sorry, my bad. I didn’t mean “Gaming over Smart Home” I meant “from Gaming to Smart Home” when listing my interests 😉. That’s a funny ad from Bethesda though. Like it! :rolling_on_the_floor_laughing: 1 ex_pat_pat Jan 28, 2022, 3:51 PM Limarc Ambalina Speaking about Gaming though, I recently discovered Google Stadia as a great platform to satisfy my casual appetite for the newest games. Great platform, with flaws though. Jack Boreham Jan 30, 2022, 2:29 PM ex_pat_pat Stadia is great! Thank you for this AMA Patrick a pleasure to have you join us. Where can people find you and check out tyny. dev? 😄 ex_pat_pat Jan 30, 2022, 9:28 PM Jack Boreham Thanks for having me. The pleasure was mine. is the company website, the product website and we’re available on all major socials. I’m more than happy to connect, thanks again for the great conversation and for inviting me. http://totally-nerdy.com http://tyny.dev

Simplifying API with Tyny.dev Founder Patrick Pittich-Rinnerthaler 

Imagine: You are about to sit down with a newly-fetched data set , excited about the insights it will bring you and then you find out it is no use. If you’ve been there, then you know for sure what an untidy dataset is. A statistician from New Zealand once said: Tidy are all alike, but every messy dataset is messy in its own way. Indeed, as data may come in various forms and shapes, sometimes we are inundated with it. datasets As a result, our data science team becomes shortsighted and oops.. disillusioned by mountains of . The only way data is by keeping data clean and organized. unworkable data specialists can facilitate analysis What is Tidy Data? Essentially, tidy data is a term coined by Hadley Wickham in his Tidy Data paper (remember that statistician from NZ?). He defined tidy data as data that is neatly organized and all . set for analysis This way of organizing allows you to easily produce charts, diagrams, and . As it often happens, not all data comes out of the database clean, therefore to efficiently analyze it. summary statistics cleansing it is essential Without further ado, let us break down the principles that allow you keep your data nice and clean. Tidy Data Principles 1. Each row is an Observational Unit We’ll start with one of the basic principles. When you are giving your data the once-over, you should make sure each row .By definition, observation is the individual unit under question. contains an observation If we look at the table above, an observational unit could be called ‘people’. You can see that each person has an individual row on the table and all of the information for that person is in the same row. Observations are included in rows, variables are represented as columns and there is only one observational unit per table. Now THIS is tidy data. 2. Each Column is a Variable A variable is the unit you are assessing. Again, if we turn to our table above, age, hair_color and height fall within the . category of variables In tidy data each variable is represented in a separate column. Okay, now a one-second quiz: What is wrong with this dataset? Yep, you guessed it right. Never put multiple variables in one column, . otherwise your data analysis is doomed 3. Each Cell is a Value If you have got hold of the first two principles, this one . should already be a no-brainer Anyway, we’ll make an extra effort to lay it all out. Each cell should contain only one value. It is also important that all values in the same column are formatted the same way. On this data set, you can see that we have a table with four variables and three observations. Each cell contains one piece of information and . All of our age values are digits, hair color values are whole words – you get the idea. Therefore, this . our values all match dataset is tidy and almost fit for analysis 4. Each Column has a Unique Name , columns should have specific and descriptive names. Let us demonstrate you an example of this principle. In an ideal dataset The third column is labeled hair_color. This is a more specific heading that if we were simply to call it – hair. The word ‘hair’ can refer to anything from hair length to hairstyle. This will help you speed up the analysis process. level of specificity The Final Word Tidy data is an of realizing the full data potential that exists. , it can be used as input into a wide range of other functions. essential part Once your data is tidy

Can We Make Data Tidy?

This post shares about the idea of applying organising method to your digital photos, and I developed an IOS app  with AppleML and PhotoKits to solve the problem. I share my reflection on lean product development strategy and my journey of making the app end-to-end using a minimum, iterable tech stack and strategy. Kon Marie It started with our own problem with managing photos on our phones (which, we found out that many other people also had). As parents with young kids, or more accurately, as humans who own smartphones that have cameras, we co-produce gigantic loads of photos. Phone storage is outgrown so easily (remember when16GBs was enough, then 32GBs, then 128GBs. No, they never really are). How do people back up their phone photos? Our private Facebook or Instagram photo albums help a bit with curating the best shots we want to remember, but quite limited. There are definitely more photos that we want to keep, and we do not wish to upload many of them to these platforms. Cloud photo storage solutions (like Google Photos) can be a back up solution, they keep photos safe. The problem with them is, these 100’s of GBs of photos will be , in other words, 99% photos have very little chance of us browsing through them again. stale The problem of putting everything in the “garage” Anyone that has a physical garage would know this “garage hoarding” problem — stuff that you stash in the garage that you hope will be useful some day. In reality, many of them will just sit there covered with dust forever. Piling up stuff in the “garage” isn’t good for your soul. Photo by NeONBRAND on Unsplash Come back to the photos. We believe the fundamental solution is to keep our photos tidy and in manageable number. And so will be our memories. In fact, a quick review of our recent photos easily shows the 90% — 10% line. 90% of photos are random snaps, spammy shots, the “9 other blurry copies”, cute-but-not-really-needed-to-keep ones. The 10% that worth keeping are the special occasions, the birthdays, the new picnic places, the unique moments. Plus occasional random shots here and there would be fine, too. Indeed, if we could find the 10% we want to keep and clean up the rest, a quick calculation would show my phone storage would be full only after 7 years. And everything can stay on my device. What is the problem we want to solve? Each time the phone is full — we face that dreaded question — should we back up these Gigabytes of photos? Often, we have to — because deleting everything is not an option. Selectively cleaning up thousands of photos is impossible. all Cleaning-up is best done on a basis. Some even say it is the only possible way. If you leave your kitchen untidy for a week, it is 10x as hard to tidy up. regular We acknowledge that there will be people who simply ain’t interested in tidying or organising stuff . For those who are, there will be benefits far beyond reclaiming storage and keeping your photos in check. After all, people bought a best-selling book to learn just about tidying. The Marie Kondo way Marie Kondo, the author of “ ” (who admittedly was on trend an eternity ago) offered some parallel thoughts with her trademark KonMarie philosophy. To simplify your life, so Kondo suggested, you either put your possessions to use, or you should let them go. The life-changing magic of tidying up Removing stuff, while counter-intuitive to human possessive tendency, helps you (stashing stuff in garage doesn’t count) more stuff by focusing only on those that matter. Consequently, it gives you the joy of living in the present. actually keep The idea As all know, once-off clean up is easy. Building a habit is really hard. Or else, the book would not be a best seller. Just look at kitchens or cupboards. This is where the idea of an app came in. How can it help? A reminder A “Swiss knife” photo clean up utility built in with KonMarie principle — the 90% -10% principle (explained above) An AI assistant that help suggest what to keep, based on intelligent image recognition (for instance, photos with faces, or non-blurry photos, on average, are more valuable) and understanding your preference A habit builder (via incentives and clear goal settings ) A safe, friction-less way to clean up your photos with plenty of safety and reversibility measures in place. The last point proved to be extremely important, as I learned after validating the product, which will be elaborated in the product development session. This is how the end product looks like — I have published an app to Apple’s App Store. If you are keen to try the app itself, please visit or get it from the . https://three-a-day.app Apple App Store Starting out At my current workplace (ThoughtWorks Australia), I am blessed to be embedded in a place with excellent innovation and learning culture. (On a side note, with the current pandemic has been harsh for many people — I have to admit we are really fortunate to still have opportunities to work and learn during this difficult time). People here love trying and building innovative things, especially in the data & AI/ML space. Our amazing colleagues have produced really cool stuff, from , to the project using advanced analytics to guide improvement, to using deep learning on edge device. real-time AI-powered sock sorting using event streaming and transfer learning “Strava for Wheelie” counting bees While we all certainly had plenty of fun (you can be sure by the names), we love such projects also because of the learning opportunities. They afford us sharp opinions from a practical experience perspective. In this series of blog posts, I am sharing my learning from this side project. I reflect specifically on applying product thinking, finding a suitable lean strategy that allowed me to finish the app end-to- end in tiny chunks (it took many months), AI/ML and image tech in IOS app development, and the minimum tech stack needed for get my app off the ground. Part 2 —Product thinking: on lean, setting up the project to fail fast, finding an iterable strategy, and finding suitable product goals Part 3 — Technical considerations and the minimum tech stack to finish the app end to end: tools, techniques, architecture, Swift, Apple ML and Photos Kit, App publishing and performance tuning Part 4— Final tips and thoughts— asking for help when you need, using external resources, and how to not let exciting projects consume your life

The “Magic of Tidying for Photos” App — Introduction

Tidy Fridy — a plan for ongoing code care

Using Scanned Mesh Data for Auto-Digitized 3D Modeling: Conclusion & Future Work and References

It's been a while since my last appearance, but I'm excited to be back and to share something truly special with you. In this article, we'll explore my top 10 Google Sheets features that are guaranteed to boost your productivity, speed up your workflow, and make your data handling more efficient. So, without further ado, let's dive into these game-changing tools! https://youtu.be/iHAvhGO0Df0?si=j6ePVf_Y5814jupV&embedable=true Autofill One of the simplest yet most effective features in Google Sheets is Autofill. Imagine you need to input numbers from 1 to 100—instead of typing each one, simply start the sequence, grab the blue dot at the corner of the cell, and drag down. Google Sheets will fill the rest for you. This works not just with numbers, but with days of the week and months of the year too, saving you a significant amount of time. Removing Whitespace and Duplicates When working with large datasets, cleaning up data is crucial. Google Sheets makes this easy with tools to eliminate unwanted whitespace and duplicates. Just select your range, use the "Trim whitespace" option under Data Cleanup, and voilà—clean, tidy cells. Similarly, the "Remove duplicates" feature ensures that only unique values remain, streamlining your data for better analysis. Alternating Colors Enhancing readability can significantly improve the way you interact with your data. The "Alternating colors" feature applies different colors to alternating rows, making your spreadsheet easier to read and reducing errors when reviewing large blocks of data. Embedding Sheets in Web Pages For those who wish to integrate Google Sheets with their websites, the ability to embed sheets is invaluable. Simply choose to embed your document, copy the provided HTML code, and paste it into your website. This allows you to display live, interactive data directly on your web pages. Data Validation for Dates Data integrity can be maintained by restricting input to certain types of data. For example, you can set a cell to only accept dates. This is done through data validation, where you select "Date" as the criteria, and Google Sheets will provide a handy date picker to ensure accuracy. Importing HTML Need to pull data from a webpage into your spreadsheet? The "ImportHTML" function is your friend. Just write the formula, specify the URL, and choose the table you wish to import. This feature not only saves time but also ensures you can quickly update your spreadsheet with the latest web data. Extracting Unique Values To identify unique entries from a range, the "Unique" function is perfect. It extracts distinct values from your selected range, allowing you to see just the unique information without any repeats. Quick Sheet Creation If you need to create a new spreadsheet quickly, just type "sheets.new" in your Chrome address bar. This shortcut instantly opens a new Google Sheet, helping you get to work right away without navigating through menus. Import Range Sometimes, you might need to share data from a spreadsheet without giving access to the entire file. "Import Range" allows you to import specific ranges from one Google Sheet to another, keeping the data synchronized without manual intervention. Google Translate in Sheets Google Sheets can even translate text directly within cells using the "Google Translate" function. Simply specify the cell, the source language, and the target language, and the translation updates in real-time. Bonus Tip Column Stats For data analysts, the "Column Stats" add-on provides quick statistical insights into data columns without needing to apply complex formulas. This tool is excellent for a high-level overview of data characteristics. Inserting Images in Cells A lesser-known but handy feature is the ability to insert images directly into cells. This functionality allows for a more organized display of visual data, which can be particularly useful for inventory lists, directories, and catalogs. I hope you find these tips helpful for making the most out of Google Sheets. If you enjoyed this article, please consider liking and sharing it. Your feedback is always welcome, so feel free to drop a comment below. Don't forget to subscribe for more useful content, and I look forward to seeing you in future articles! Thank you for your support and happy sheeting! It's been a while since my last appearance, but I'm excited to be back and to share something truly special with you. In this article, we'll explore my top 10 Google Sheets features that are guaranteed to boost your productivity, speed up your workflow, and make your data handling more efficient. So, without further ado, let's dive into these game-changing tools! https://youtu.be/iHAvhGO0Df0?si=j6ePVf_Y5814jupV&embedable=true https://youtu.be/iHAvhGO0Df0?si=j6ePVf_Y5814jupV&embedable=true Autofill One of the simplest yet most effective features in Google Sheets is Autofill. Imagine you need to input numbers from 1 to 100—instead of typing each one, simply start the sequence, grab the blue dot at the corner of the cell, and drag down. Google Sheets will fill the rest for you. This works not just with numbers, but with days of the week and months of the year too, saving you a significant amount of time. Removing Whitespace and Duplicates When working with large datasets, cleaning up data is crucial. Google Sheets makes this easy with tools to eliminate unwanted whitespace and duplicates. Just select your range, use the "Trim whitespace" option under Data Cleanup, and voilà—clean, tidy cells. Similarly, the "Remove duplicates" feature ensures that only unique values remain, streamlining your data for better analysis. Alternating Colors Enhancing readability can significantly improve the way you interact with your data. The "Alternating colors" feature applies different colors to alternating rows, making your spreadsheet easier to read and reducing errors when reviewing large blocks of data. Embedding Sheets in Web Pages For those who wish to integrate Google Sheets with their websites, the ability to embed sheets is invaluable. Simply choose to embed your document, copy the provided HTML code, and paste it into your website. This allows you to display live, interactive data directly on your web pages. Data Validation for Dates Data integrity can be maintained by restricting input to certain types of data. For example, you can set a cell to only accept dates. This is done through data validation, where you select "Date" as the criteria, and Google Sheets will provide a handy date picker to ensure accuracy. Importing HTML Need to pull data from a webpage into your spreadsheet? The "ImportHTML" function is your friend. Just write the formula, specify the URL, and choose the table you wish to import. This feature not only saves time but also ensures you can quickly update your spreadsheet with the latest web data. Extracting Unique Values To identify unique entries from a range, the "Unique" function is perfect. It extracts distinct values from your selected range, allowing you to see just the unique information without any repeats. Quick Sheet Creation If you need to create a new spreadsheet quickly, just type "sheets.new" in your Chrome address bar. This shortcut instantly opens a new Google Sheet, helping you get to work right away without navigating through menus. Import Range Sometimes, you might need to share data from a spreadsheet without giving access to the entire file. "Import Range" allows you to import specific ranges from one Google Sheet to another, keeping the data synchronized without manual intervention. Google Translate in Sheets Google Sheets can even translate text directly within cells using the "Google Translate" function. Simply specify the cell, the source language, and the target language, and the translation updates in real-time. Bonus Tip Column Stats For data analysts, the "Column Stats" add-on provides quick statistical insights into data columns without needing to apply complex formulas. This tool is excellent for a high-level overview of data characteristics. Inserting Images in Cells A lesser-known but handy feature is the ability to insert images directly into cells. This functionality allows for a more organized display of visual data, which can be particularly useful for inventory lists, directories, and catalogs. I hope you find these tips helpful for making the most out of Google Sheets. If you enjoyed this article, please consider liking and sharing it. Your feedback is always welcome, so feel free to drop a comment below. Don't forget to subscribe for more useful content, and I look forward to seeing you in future articles! Thank you for your support and happy sheeting!

Top 10 Favorite Google Sheets Features for Everyday Work

This paper is under CC 4.0 license. available on arxiv Authors: (1) Jinrui Yang, School of Computing & Information Systems, The University of Melbourne (Email: jinruiy@student.unimelb.edu.au); (2) Timothy Baldwin, School of Computing & Information Systems, The University of Melbourne and Mohamed bin Zayed University of Artificial Intelligence, UAE (Email: (tbaldwin,trevor.cohn)@unimelb.edu.au); (3) Trevor Cohn, School of Computing & Information Systems, The University of Melbourne. Table of Links Abstract and Intro Background and Related Work Multi-EuP Experiments and Findings Language Bias Discussion Conclusion, Limitations, Ethics Statement, Acknowledgements, References, and Appendix 6 Conclusion In this paper, we introduce Multi-EuP, a novel dataset for multilingual information retrieval across 24 languages, collected from European Parliament debates. The demographic information provided by the Multi-EuP dataset serves a dual purpose: not only does it contribute to multilingual retrieval tasks, but it also holds significant potential for advancing research in the realm of fairness and bias. This dataset can play a pivotal role in investigating issues of equitable representations and mitigation of biases within document ranking settings. Multi-EuP facilitates diverse information retrieval (IR) scenarios, encompassing one-vs-one, one-vs-many, and many-vs-many settings. We demonstrated the utility of Multi-EuP as a benchmark for evaluating both monolingual and multilingual IR. Our study reveals the presence of language bias in multilingual IR when employing BM25. We further validate the effectiveness of mitigating this bias through the strategic implementation of whitespace as a language tokenizer. We propose to conduct future work in three main areas. First, we intend to expand our investigation of language bias to encompass a broader range of ranking methods, including neural methods such as mDPR (Zhang et al., 2021), mColBERT (Lawrie et al., 2023) and PLAID-X(Santhanam et al., 2022). Second, we will expand the dataset by developing an automated API to retrieve data published by the European Parliament (EP), thereby ensuring realtime synchronization of our dataset. Lastly, our current experiments have explored language bias only, but we plan to further investigate gender bias, age bias, and nationality bias. Limitations The limitations of the Multi-EuP dataset are notable but navigable. Primarily, the temporal coverage of the dataset is confined to the past three years. This temporal constraint arises due to the fact that, preceding 2020, documents released by the EU were predominantly available in mono-lingual versions only. However, a potential remedy lies in the amalgamation of the Europarl (Koehn, 2005) collection, enabling a more comprehensive and holistic MultiEuP dataset. Furthermore, it is worth noting the domain skew of the dataset, in that Multi-EuP inevitably centers on political matters. While this presents challenges, particularly in terms of the intricate nuances of political language, it inherently serves as an excellent foundational stepping stone for delving into the intricacies of multilingual retrieval. We believe, however, that this dataset can serve as a launching pad for broader explorations encompassing crossdomain and open-domain transfer learning scenarios, thus contributing to the broader landscape of language understanding and retrieval. Ethics Statement The dataset contains publicly-available EP data that does not include personal or sensitive information, with the exception of information relating to public officeholders, e.g., the names of the active members of the European Parliament, European Council, or other official administration bodies. The collected data is licensed under the Creative Commons Attribution 4.0 International licence. [8] Acknowledgements This research was funded by Melbourne Research Scholarship and undertaken using the LIEF HPCGPGPU Facility hosted at the University of Melbourne. This facility was established with the assistance of LIEF Grant LE170100200. We would like to thank George Buchanan for providing valuable feedback. References Luiz Henrique Bonifacio, Israel Campiotti, Roberto de Alencar Lotufo, and Rodrigo Frassetto Nogueira. 2021. mMARCO: A multilingual version of MS MARCO passage ranking dataset. CoRR, abs/2108.13897. Ilias Chalkidis, Manos Fergadiotis, and Ion Androutsopoulos. 2021. MultiEURLEX - a multi-lingual and multi-label legal document classification dataset for zero-shot cross-lingual transfer. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pages 6974–6996, Online and Punta Cana, Dominican Republic. Association for Computational Linguistics. 8 https://eur-lex.europa.eu/cont Jonathan H. Clark, Eunsol Choi, Michael Collins, Dan Garrette, Tom Kwiatkowski, Vitaly Nikolaev, and Jennimaria Palomaki. 2020. TyDi QA: A benchmark for information-seeking question answering in typologically diverse languages. Transactions of the Association for Computational Linguistics, 8:454–470. Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. 2020. Dense passage retrieval for opendomain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 6769–6781, Online. Association for Computational Linguistics. Omar Khattab and Matei Zaharia. 2020. Colbert: Efficient and effective passage search via contextualized late interaction over BERT. CoRR, abs/2004.12832. Philipp Koehn. 2005. Europarl: A parallel corpus for statistical machine translation. In Proceedings of Machine Translation Summit X: Papers, pages 79–86, Phuket, Thailand. Dawn Lawrie, Eugene Yang, Douglas W. Oard, and James Mayfield. 2023. Neural approaches to multilingual information retrieval. arXiv cs.IR 2209.01335. Jimmy Lin, Xueguang Ma, Sheng-Chieh Lin, JhengHong Yang, Ronak Pradeep, and Rodrigo Nogueira. 2021. Pyserini: A Python toolkit for reproducible information retrieval research with sparse and dense representations. https://github.com/ castorini/pyserini. Tri Nguyen, Mir Rosenberg, Xia Song, Jianfeng Gao, Saurabh Tiwary, Rangan Majumder, and Li Deng. 2016. MS MARCO: A human generated machine reading comprehension dataset. CoRR, abs/1611.09268. Ella Rabinovich, Raj Nath Patel, Shachar Mirkin, Lucia Specia, and Shuly Wintner. 2017. Personalized machine translation: Preserving original author traits. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers, pages 1074–1084, Valencia, Spain. Association for Computational Linguistics. Razieh Rahimi, Azadeh Shakery, and Irwin King. 2015. Multilingual information retrieval in the language modeling framework. Information Retrieval Journal, 18:246–281. Keshav Santhanam, Omar Khattab, Christopher Potts, and Matei Zaharia. 2022. PLAID: An efficient engine for late interaction retrieval. In Proceedings of the 31st ACM International Conference on Information & Knowledge Management, CIKM ’22, page 1747–1756, New York, NY, USA. Association for Computing Machinery. Jörg Tiedemann and Santhosh Thottingal. 2020. OPUSMT – building open translation services for the world. In Proceedings of the 22nd Annual Conference of the European Association for Machine Translation, pages 479–480, Lisboa, Portugal. European Association for Machine Translation. Eva Vanmassenhove and Christian Hardmeier. 2018. Europarl datasets with demographic speaker information. In Proceedings of the 21st Annual Conference of the European Association for Machine Translation, page 391, Alicante, Spain. Denny Vrandeciˇ c and Markus Krötzsch. 2014. ´ Wikidata: A free collaborative knowledge base. Communications of the ACM, 57:78–85. Konrad Wojtasik, Vadim Shishkin, Kacper Wołowiec, Arkadiusz Janz, and Maciej Piasecki. 2023. BEIRPL: Zero shot information retrieval benchmark for the Polish language. arXiv cs.IR 2305.19840. Peilin Yang, Hui Fang, and Jimmy Lin. 2017. Anserini: Enabling the use of lucene for information retrieval research. In Proceedings of the 40th International ACM SIGIR Conference on Research and Development in Information Retrieval, pages 1253–1256. Xinyu Zhang, Xueguang Ma, Peng Shi, and Jimmy Lin. 2021. Mr. TyDi: A multi-lingual benchmark for dense retrieval. arXiv cs.CL 2108.08787. A. Appendix [8] https://eur-lex.europa.eu/content/ legal-notice/legal-notice.html

Multi-EuP: Analysis of Bias in Information Retrieval - Conclusion, Limitations, and Ethics Statement

This paper is under CC 4.0 license. available on arxiv Authors: (1) Jinrui Yang, School of Computing & Information Systems, The University of Melbourne (Email: jinruiy@student.unimelb.edu.au); (2) Timothy Baldwin, School of Computing & Information Systems, The University of Melbourne and Mohamed bin Zayed University of Artificial Intelligence, UAE (Email: (tbaldwin,trevor.cohn)@unimelb.edu.au); (3) Trevor Cohn, School of Computing & Information Systems, The University of Melbourne. Table of Links Abstract and Intro Background and Related Work Multi-EuP Experiments and Findings Language Bias Discussion Conclusion, Limitations, Ethics Statement, Acknowledgements, References, and Appendix 4 Experiments and Findings We conduct preliminary experiments in both one-vs-one and one-vs-many settings, as described above. We base our experiments on BM25 with default settings (k1 = 0.9 and b = 0.4), a popular traditional information retrieval baseline. Our implementation is based on Pyserini (Lin et al., 2021), which is built upon Lucene (Yang et al., 2017). Notably, the latest LUCENE 8.5.1 API offers language-specific tokenizers, [6] covering 19 out of the 24 languages present in Multi-EuP. For the remaining languages — namely Polish (PL), Croatian (HR), Slovak (SK), Slovenian (SL), and Maltese (MT) — we use a whitespace tokenizer. Methods MRR@k denotes MRR computed at a depth of results. Note that the higher the number the better, and that a perfect retriever achieves an MRR of 1 (assuming every query has at least one relevant document). The choice of setting = 100 aligns with prior endeavors over MS MARCO (Nguyen et al., 2016). k k 4.1 Monolingual IR ( ) one-vs-one We first present results over Multi-EuP in a monolingual setting across the 24 different languages. Specifically, we evaluate single-language queries against documents in the same language. In this configuration, we partitioned our original collection of 22K documents into 24 distinct language-specific sub-collections. Table 2 presents the results broken down across languages. Experimental Setup Table 2 presents the MRR@100 results for BM25 on Multi-EuP. There are two high-level findings: Results and Findings First, Multi-EuP is a relatively easy benchmark for monolingual information retrieval, as the MRR@100 is always around 40 or greater (meaning that the first relevant document is in the top-3 results on average). Indeed, the average MRR across the 24 test languages is 49.61. While direct comparison is not possible, it is noteworthy that for Mr. TYDI, the average MRR is 32.1 across 11 languages. Part of this difference can be attributed to the fact that our relevance judgments are not as sparse as theirs. Second, similar to Mr. TYDI, direct comparison of absolute scores between languages is not meaningful in a monolingual setting, as the document collection size differs. 4.2 Multilingual IR ( ) one-vs-many In contrast to Mr. TYDI (Zhang et al., 2021), Multi-EuP supports one-vs-many retrieval, and allows us to systematically explore the effect of querying the same document collection with the same set of topics in different languages. This is because we have translations of the topics in all languages, documents span multiple languages, and judgments are cross-lingual (e.g., English queries potentially yield relevant Polish documents). For this experiment, we use the default whitespace tokenizer in the Pyserini library. Experimental Setup Results and Findings Table 2 presents the MRR results for BM25 for multilingual information retrieval on 100 topics from the Multi-EuP test set. It’s worth noting that these topics have translationequivalent content in the different languages. Consequently, the one-vs-many approach allows us to analyze language bias. We made several key observations: First, unsurprisingly, having more relevance judgments tends to improve ranking accuracy. Therefore, when comparing English topics with other languages, English exhibits notably better MRR performance. Second, despite there being consistency in the topics, document collection, and relevance judgments, there is a significant disparity in MRR scores across languages, an effect we investigate further in the next section. [6] Provided by the Anaylzer package in LUCENE. https: //lucene.apache.org/core/8_5_1/analyzers-common/ index.html

Multi-EuP: Analysis of Bias in Information Retrieval - Experiments and Findings

This paper is under CC 4.0 license. available on arxiv Authors: (1) Jinrui Yang, School of Computing & Information Systems, The University of Melbourne (Email: jinruiy@student.unimelb.edu.au); (2) Timothy Baldwin, School of Computing & Information Systems, The University of Melbourne and Mohamed bin Zayed University of Artificial Intelligence, UAE (Email: (tbaldwin,trevor.cohn)@unimelb.edu.au); (3) Trevor Cohn, School of Computing & Information Systems, The University of Melbourne. Table of Links Abstract and Intro Background and Related Work Multi-EuP Experiments and Findings Language Bias Discussion Conclusion, Limitations, Ethics Statement, Acknowledgements, References, and Appendix 3 Multi-EuP In our approach, we consider the debate topics to be the queries, and the text of each individual speech delivered by an MEP to be a document. The topics are officially annotated by the EU, and professionally translated into 24 different languages.[5] During preprocessing, we filter out procedural debate topics such as , leaving 1.1K unique topics. They will serve as a valuable resource for assessing language bias in multilingual ranking methods, given that all the topics across different languages are semantically consistent. Topics agenda The 22K multilingual documents within the Multi-EuP dataset originate from MEP speeches during parliamentary debates. Each document annotated with additional metadata, including the date of the speech, the MEP ID, and a link to the video recording for potential multimodal research but not used here. Table 1 shows a detailed breakdown of the language distribution and descriptive statistics of the dataset. We include in our corpus documents only in the original language, as spoken by the MEP, but not their translations into other languages. Our only use of translations is the debate topics themselves. Documents To assess the relevance of documents to a given query, we use a binary relevance judgment, based on whether the speech was part of a debate on the given topic, resulting in one positive relevance judgment per document, meaning that the document collection is much less sparse than Mr. TYDI and MS MARCO, for example. Judgments Multi-EuP covers 24 EU languages from seven families (Germanic, Romance, Slavic, Uralic, Baltic, Semitic, Hellenic), each of which is the official language of one or more member states. Table 1 provides a breakdown of each language’s EU usage, member state distribution, and population, using ISO-639 codes. Languages Multi-EuP encompasses 705 members elected across the 27 member states of the EU. We constructed the MEP dictionary by collecting MEP attributes such as and . We further annotated MEPs with gender and their birthdate, based on Wikipedia profiles and Rabinovich et al. (2017), and manually checked if difference existing. Figure 1 illustrates the gender and age distribution across MEPs, with male MEPs being more than twice as numerous as female MEPs, and the majority falling within the 40– 70 age range. This corpus is rare, perhaps unique, due to its richly detailed speaker demographic information, which enables research on fairness and bias in information retrieval. MEP name, photo, id in EU, nationality, place of birth, party affiliation, spoken language For data splitting, we select two sets with 100 language-specific and distinct topics for development and test set in 24 languages, and keep the remaining topics to the training set. This design choice was made to maintain an ample supply of topics and judgment samples essential for the training of deep learning models, and also facilitate subsequent cross-lingual comparative research. Data Split Similarly to Mr.TYDI (Zhang et al., 2021), Multi-EuP can be used for monolingual retrieval in English as well as non-English languages (eg. Swedish queries against Swedish documents). However, unlike Mr.TYDI, Multi-EuP encompasses multilingual documents and identical multilingual topics, ensuring that queries in different languages can be compared. Consequently, Multi-EuP can support diverse information retrieval experimental tasks. These including scenarios with single one language queries against single one language documents, in other words, monolingual or cross-lingual IR, scenarios with single-language queries against multilingual documents, i.e., multilingual IR, and scenarios involving multilingual queries against multilingual documents, i.e, mixed multilingual IR). Supported Task one-vs-one one-vs-many many-vs-many [5] https://www.europarl.europa.eu/translation/ en/translation-at-the-european-parliament/

Multi-EuP: Analysis of Bias in Information Retrieval - Multi-EuP Use

This paper is under CC 4.0 license. available on arxiv Authors: (1) Jinrui Yang, School of Computing & Information Systems, The University of Melbourne (Email: jinruiy@student.unimelb.edu.au); (2) Timothy Baldwin, School of Computing & Information Systems, The University of Melbourne and Mohamed bin Zayed University of Artificial Intelligence, UAE (Email: (tbaldwin,trevor.cohn)@unimelb.edu.au); (3) Trevor Cohn, School of Computing & Information Systems, The University of Melbourne. Table of Links Abstract and Intro Background and Related Work Multi-EuP Experiments and Findings Language Bias Discussion Conclusion, Limitations, Ethics Statement, Acknowledgements, References, and Appendix 2 Background and Related Work The European Parliament (EP) serves as an important forum for political debates and decisionmaking at the European Union level. Members of the European Parliament (MEP) are elected in direct elections across the EU. The European Parliament debate is presided over by the President, who guides MEPs in discussing specific subjects. EP debates have been the source of three key datasets. First, was crafted by Koehn (2005) by collecting EP debates documents from 1996 to 2011, and extracting translations as a parallel corpus for statistical machine translation, enriched with attributes including , and Europarl-2005 debate date chapter id, MEP id, language, MEP name, MEP party. Later, Rabinovich et al. (2017) built upon , by introducing additional demographic attributes: MEP gender and . These were sourced from sources such as Wikidata (Vrandeciˇ c and Krötzsch ´ , 2014) and automatic annotation tools such as *Genderize[*2] and . [3] However, is limited to only two language pairs: English– German and English–French. (Vanmassenhove and Hardmeier, 2018) expanded upon to add twenty additional language pairs, based on the manual translations in the EP archives. These corpora have been used primarily for machine translation research. Europarl2017 Europarl-2005 MEP age AlchemyVision Europarl-2017 Europarl-2018 Europarl-2017 Since 2020, the EU has publicly released raw debates in the form of transcribed source-language speeches with rich multilingual topic index data, along with the original video and audio recordings. This forms the basis of the Multi-EuP dataset, with additional attributes for each speaking MEP such as an image, birthplace, and nationality. Zhang et al. (2021) introduced Mr. TYDI, an evaluation benchmark dataset for dense retrieval assessment over 11 languages. This dataset is constructed from TYDI (Clark et al., 2020), a question answering dataset. For each language, annotators assign relevance scores as judgments for questions, derived from Wikipedia articles. Notably, the questions for different languages are crafted independently, and relevance judgements are provided in-language only. Based on the dataset, the authors evaluate on monolingual retrieval tasks for non-English languages using BM25 and mDPR as zero-shot baselines. However, Mr. TYDI’s scope is limited in that it is not truly multilingual, in that queries in a given language are only performed over documents in that language. This is part of the void our work aims to address. MS MARCO (Nguyen et al., 2016) is a widelyused dataset, sourced from Bing’s search query logs, but for English queries and documents only. To mitigate this, Bonifacio et al. (2021) introduced mMARCO, a multilingual variant of the MS MARCO passage ranking dataset, spanning 13 languages and created through machine translation, based on one open-source approach (Tiedemann and Thottingal, 2020) and one commercial system in the form of Google Translate.[4] Analysis of the authors’ results reveals a positive correlation between translation quality and retrieval performance, with higher translation BLEU scores yielding improved retrieval MRR outcomes. However, similar to Mr. TYDI, mMARCO focuses on in-language retrieval only for multiple languages, rather than multilingual retrieval. Throughout the past few decades, numerous datasets and tasks pertaining to multilingual retrieval have been developed for evaluation, through efforts such as CLEF, TREC, and FIRE, each contributing standardized document collections and evaluation procedures. These evaluation datasets facilitate genuine multilingual IR research such as Rahimi et al. (2015) and Lawrie et al. (2023). However, the scope of these datasets is generally limited to a small number of queries. For example, in the case of CLEF 2001-2003, each edition encompasses a mere few dozen queries. This limitation tends to confine research predominantly to evaluation and not offer a resource for training a multilingual ranking model. Our dataset is of a scale to accommodate both large-scale training and evaluation of multilingual retrieval methods. Compared with the related work above, our work augments the multilingual mixture of queries and documents compared to Mr.TYDI, preserves the authenticity of multilingual contexts compared to mMARCO’s translation-based approach, and surpasses the query count limitations of tasks like CLEF. [2] https://genderize.io/ [3] https://www.ibm.com/smarterplanet/us/en/ ibmwatson/developercloud/alchemy-vision.html [4] https://cloud.google.com/translate

Multi-EuP: Analysis of Bias in Information Retrieval - Background and Related Work

This paper is under CC 4.0 license. available on arxiv Authors: (1) Jinrui Yang, School of Computing & Information Systems, The University of Melbourne (Email: jinruiy@student.unimelb.edu.au); (2) Timothy Baldwin, School of Computing & Information Systems, The University of Melbourne and Mohamed bin Zayed University of Artificial Intelligence, UAE (Email: (tbaldwin,trevor.cohn)@unimelb.edu.au); (3) Trevor Cohn, School of Computing & Information Systems, The University of Melbourne. Table of Links Abstract and Intro Background and Related Work Multi-EuP Experiments and Findings Language Bias Discussion Conclusion, Limitations, Ethics Statement, Acknowledgements, References, and Appendix Abstract We present Multi-EuP, a new multilingual benchmark dataset, comprising 22K multilingual documents collected from the European Parliament, spanning 24 languages. This dataset is designed to investigate fairness in a multilingual information retrieval (IR) context to analyze both language and demographic bias in a ranking context. It boasts an authentic multilingual corpus, featuring topics translated into all 24 languages, as well as cross-lingual relevance judgments. Furthermore, it offers rich demographic information associated with its documents, facilitating the study of demographic bias. We report the effectiveness of Multi-EuP for benchmarking both monolingual and multilingual IR. We also conduct a preliminary experiment on language bias caused by the choice of tokenization strategy. 1 Introduction Information retrieval (IR) classically uses a retrieval model to query a document collection and return a ranked list of documents which are predicted to be (decreasingly) relevant to the query. Retrieval models have increasingly been based on supervised learning, involving the annotation of documents with relevance scores relative to a given query, and the training of models to predict the relative association between a query and document (Karpukhin et al., 2020; Khattab and Zaharia, 2020). In parallel with these advances, the democratisation of the internet has led to a surge of individual contributors serving as information disseminators, hailing from various countries and regions, and posting in different languages. This has created possibilities for exploration of cross-lingual and multilingual text retrieval. Cross-lingual retrieval pertains to scenarios where queries are formulated in one language but documents are retrieved from another language. On the other hand, multilingual retrieval involves a query in one language but retrieval of documents across multiple languages simultaneously. An important consideration in any such work is both robustness and fairness across different combinations of languages – for instance, are results from one language consistently ranked higher than another for certain types of query. While progress towards multilingual retrieval through the release of datasets such as Mr. TYDI (Zhang et al., 2021) and mMARCO (Bonifacio et al., 2021), both are limited in that they evaluate monolingual retrieval for a range of languages, rather than true multilingual retrieval, using multiple languages simultaneously. Additionally, mMARCO was created by machine translation of MS MARCO (Nguyen et al., 2016), introducing a confounding factor of translation errors. We present a multilingual dataset based on the European Parliament debate archive with queries in 24 distinct languages, and relevance judgements also across all 24 languages. This ensures the “multilingual” nature of the dataset in terms of both query-to-document and document-to-query associations. We additionally augment each document with comprehensive metadata of the author, including gender, nationality, political affiliation, and age, for use in exploring fairness with respect to protected attributes. Our work contributes to the field in three main ways: (1) we construct and release the Multi-EuP dataset, a resource for multilingual retrieval over 24 languages, effectively capturing the multilingual nature of both queries and documents; (2) we explore language bias within the realm of multilingual retrieval, revealing that multilingual IR using BM25 indeed exhibits notable language bias; and (3) we supplement the dataset with rich author metadata to enable research on fairness and demographic bias in IR.[1] [1] The Multi-EuP dataset is available for download from https://github.com/jrnlp/Multi-EuP.

Multi-EuP: Analysis of Bias in Information Retrieval - Abstract and Intro

The Press Release is NOT Dead (Neither is the Funding Announcement)

প্রেস রিলিজ মৃত নয় (ফান্ডিং ঘোষণাও নয়)

Die Pressemitteilung ist NICHT tot (ebenso wenig wie die Finanzierungsankündigung)

El comunicado de prensa NO está muerto (tampoco el anuncio de financiación)

Le communiqué de presse n’est PAS mort (l’annonce de financement non plus)

प्रेस विज्ञप्ति ख़त्म नहीं हुई है (न ही फंडिंग की घोषणा)

プレスリリースは死んでいない（資金調達の発表も同様）

보도 자료는 죽지 않았습니다 (펀딩 발표도 마찬가지입니다)

O comunicado de imprensa NÃO está morto (nem o anúncio de financiamento)

Пресс-релиз НЕ умер (как и объявление о финансировании)

Basın Bülteni ÖLÜ DEĞİLDİR (Finansman Duyurusu da Değil)

Thông cáo báo chí KHÔNG chết (Thông báo tài trợ cũng không)

新闻稿还没有过时（融资公告也没有过时）

In nearly all of my recent explorations of Generative AI, I've come to realize how important prompts are. That hasn't necessarily translated me into writing better prompts all the time, but being aware of the problem is at least one step towards correcting it, right? One of the things that I thought would help me personally would be to have a tool to quickly compare and contrast different prompts. Obviously, I could just open up multiple tabs in a browser, but I really wanted something more direct and simplified for my purposes. With that in mind, let me share what I've built. Prompt Tester Prompt Tester is my incredibly imaginatively named tool to... um... test prompts. It begins with one prompt: The idea is that you enter your initial prompt, and then click one or more times to add more prompts. When ready, you can then just click "Generate Results": Before showing some example results, let me talk a bit about how it was built. The Code The backend is an simple Node.js server that handles throwing up the static HTML and responding to the front-end API requests. Once again, I thank Todd Sharp for sharing his initial code with me. Here's the boring simple handling portion: incredibly async function handler(req, res) {
	console.log('Entered handler.', req.method, req.url);

	if(req.method === 'GET' && req.url.indexOf('favicon.ico') === -1) {
		res.writeHead(200, { 'Content-Type':'text/html' });
		res.write(fs.readFileSync('./demo.html'));
		res.end();
	} else if(req.method === 'POST' && req.url === '/api') {

		let body = '';
		req.on('data', chunk => {
			body += chunk.toString();
		});

		req.on('end', async () => {
			body = JSON.parse(body);
			console.log('BODY:\n', JSON.stringify(body, null, '\t'));

			let result = await callGemini(body.prompt);
			res.writeHead(200, { 'Content-Type':'application/json' });
			res.write(JSON.stringify(result));
			res.end();

		});

	}

}

const server = http.createServer(handler);
server.listen(3000);
console.log('Listening on port 3000'); And the part which just passes the prompt off to Google's . In theory, this could be changed to ChatGPT or any other service. callGemini Gemini API const MODEL_NAME = "gemini-pro";
const API_KEY = process.env.GOOGLE_AI_KEY;

const genAI = new GoogleGenerativeAI(API_KEY);
const model = genAI.getGenerativeModel({ model: MODEL_NAME });

async function callGemini(text) {

	const generationConfig = {
		temperature: 0.9,
		topK: 1,
		topP: 1,
		maxOutputTokens: 2048,
	};

	const safetySettings = [
		{ category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,	threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
	];

	const parts = [
    	{text},
  	];

	const result = await model.generateContent({
		contents: [{ role: "user", parts }],
		generationConfig,
		safetySettings,
	});

	try {

		if(result.response.promptFeedback && result.response.promptFeedback.blockReason) {

			return { error: `Blocked for ${result.response.promptFeedback.blockReason}` };
		}
		const response = result.response.candidates[0].content.parts[0].text;
		return { response };
	} catch(e) {
		// better handling
		return {
			error:e.message
		}
	}
	
} I'm proud to say that I'm now, finally, doing some basic error handling and trying to expose to the user (me) why a prompt was blocked. The front end is relatively simple. I used for the core CSS (again, thank you Todd) and some vanilla JavaScript to handle adding new prompts and making the calls. Here's the HTML (minus the inline CSS): Milligram <h1>Prompt Tester</h1>

<p>
This tool helps you see the result of multiple prompts at the same time. The idea is to use similar prompts with different phrasing 
to see how it impacts the result.
</p>

<div id="prompts">
</div>

<template id="promptRow">
<div class="row">
	<div class="column column-33"><textarea placeholder="Enter your prompt."></textarea></div>
	<div class="column column-67 result"></div>
</div>
<hr>
</template>


<div class="float-right">
<button id="addPrompt">Add Prompt</button> <button id="generateResults">Generate Results</button>
</div> And then the JavaScript. Notice I used above to handle the prompt layout. This is the first time I've used that tag, and it was relatively easy. <template> let $template, $prompts, $addPromptsBtn, $generateResultsBtn;
let promptCount = 0;

document.addEventListener('DOMContentLoaded', init, false);
async function init() {
	
	$addPromptsBtn = document.querySelector('#addPrompt');
	$addPromptsBtn.addEventListener('click',  addPrompt, false);
	$generateResultsBtn = document.querySelector('#generateResults')
	$generateResultsBtn.addEventListener('click',  generateResults, false);
	$template = document.querySelector('#promptRow');
	$prompts = document.querySelector('#prompts');

	addPrompt();
}

function addPrompt() {
	promptCount++;
	const newPrompt = $template.content.cloneNode(true);
	$prompts.append(newPrompt);
}

async function generateResults() {
	// disable add prompt and generate
	$addPromptsBtn.setAttribute('disabled', 'disabled');
	$generateResultsBtn.setAttribute('disabled', 'disabled');

	let $results = document.querySelectorAll('div.result');
	// clear any previous results
	$results.forEach(r => r.innerHTML = '');

	/*
	gather prompts from the inputs
	*/
	let prompts = [];
	let $fields = document.querySelectorAll('#prompts textarea');
	for(f of $fields) prompts.push(f.value);

	let promises = [];
	for(p of prompts) promises.push(getResult(p));
	let results = await Promise.all(promises);

	// assign results to result area for each, handle errors - later
	// there's a one to one correspondance between our array of results and the result div
	for(let i=0;i<results.length;i++) {
		if(results[i].response) $results[i].innerHTML = marked.parse(results[i].response);
		else if(results[i].error) $results[i].innerHTML = `<strong>Error with Prompt: </strong> ${results[i].error}`;
	}

	$addPromptsBtn.removeAttribute('disabled');
	$generateResultsBtn.removeAttribute('disabled');

}

async function getResult(p) {
	console.log('get result for',p);
	// quick return on empty prompt
	if(p.trim() === '') return { response:'<strong>Enter a prompt.</strong>' };
	let req = await fetch('/api', { method:'POST', body: JSON.stringify({prompt:p.trim()})});
	let result = await req.json();
	return result;
} I that's all pretty simple DOM manipulation and API calling, but definitely let me know in a comment below if something doesn't make sense. Notice I fire off all my API calls at once and wait for them to finish. think Promise.all Also, note I use the library. The results from Google typically have Markdown, and this helps render them nicely in my little web app. marked All of this isn't terribly interesting I think, but let's look at some testing. As I said, I the style of prompt was important. Having it presented directly to me in a tool went a of a long way to reinforcing that. knew heck Sample Result - Gravity Let's start with a simple idea - explaining gravity but for different age groups. Because of the large size of the results, I'm going to use a bit of CSS here to help keep things sane. Prompt: explain gravity to me but make it appropriate for a child in 1st grade Gravity is a superpower that our planet has! It's like an invisible force that makes everything on Earth stay on the ground. Imagine you have a ball in your hand. When you drop it, what happens? It falls down, right? That's because of gravity. Gravity pulls the ball towards the center of the Earth, and so it falls to the ground. Gravity is also what keeps us on the ground. It's what keeps our feet planted firmly on the Earth and prevents us from floating away! Gravity is a very important force. It keeps everything in place and helps things work the way they do. Without gravity, we would all be floating around in space, and things would be very chaotic! Here's a fun way to think about gravity: imagine that the Earth is a giant magnet, and everything on Earth is made of metal. The magnet pulls the metal objects towards it, and that's what keeps them on the ground. Gravity is a very important and interesting force. It's one of the things that makes our planet such a unique and special place to live! Prompt: explain gravity to me but make it appropriate for a child in 7th grade Imagine you're playing with a ball. You toss it up in the air, and it comes back down to you. This is because of gravity. Gravity is a force that pulls things toward each other. It's what keeps you on the ground and what makes things fall down. The amount of gravity between two objects depends on their mass. The more mass an object has, the stronger its gravity is. That's why things like planets and stars have more gravity than things like people and cars. Gravity is also what keeps the planets in orbit around the sun. The sun's gravity is much stronger than the Earth's, so it pulls the Earth towards it. This keeps the Earth moving in a circle around the sun. Gravity is a very important force in our universe. It keeps things in place and makes things move. Without gravity, the planets would fly off into space, and we would all float away. Here are some fun facts about gravity: Gravity is responsible for the tides. The moon's gravity pulls on Earth's oceans, causing them to rise and fall. Gravity is the reason why we have an atmosphere. Without gravity, the air would just float away into space. Gravity is what makes it possible for us to walk. When we walk, our feet push against the ground, and the ground pushes back. This is what propels us forward. Gravity is the reason why we don't float away into space. Earth's gravity pulls us towards its center, keeping us on the ground. Note the typo in the prompt below. Gemini handled it just fine. Prompt: explain gravity to me but make it appropriate for a college-aged student Gravity: The Force of Attraction Gravity is a fundamental force in the universe responsible for keeping celestial bodies, such as planets, moons, and stars, in motion. It is also what keeps us firmly planted to the ground and allows objects to fall when dropped. Newton's Law of Universal Gravitation: The law of universal gravitation states that every object in the universe attracts every other object with a force proportional to the product of their masses and inversely proportional to the square of the distance between them. Mathematically, it can be expressed as: F = Gm1m2/r^2 Where: F is the gravitational force between two objects. G is the gravitational constant (6.674 × 10^-11 N m^2/kg^2). m1 and m2 are the masses of the two objects. r is the distance between the centers of the two objects. Significance of Gravity: The gravitational pull of larger celestial bodies keeps smaller ones revolving around them. For example, Earth's gravity keeps the moon in orbit, while Sun's gravity keeps Earth and other planets in their respective orbits. Keeps Celestial Bodies in Orbit: Gravity between the Earth and the moon causes ocean tides. As the moon orbits Earth, its gravitational pull creates a bulge in the ocean's water on the side facing the moon. Another bulge forms on the opposite side of Earth due to the inertial forces. As the Earth rotates, these bulges move across the planet's surface, resulting in high and low tides. Responsible for Tides: Gravity pulls objects towards Earth's center, preventing them from floating away. This phenomenon allows us to walk, stand, and interact with our environment. Keeps Objects on Earth: Gravity plays a crucial role in the formation of stars and galaxies. The gravitational collapse of massive clouds of gas and dust leads to the creation of new stars. Similarly, the gravitational pull of galaxies keeps them bound together, preventing them from dispersing. Formation of Stars and Galaxies: Albert Einstein's general relativity theory provides a more comprehensive understanding of gravity. It explains that gravity is not a force but rather a curvature of spacetime caused by the presence of mass or energy. This curvature affects the motion of objects, causing them to follow curved paths rather than straight lines. Relativity Theory: In conclusion, gravity is a fundamental force responsible for keeping celestial bodies in motion, tides, and the behavior of objects on Earth. It is a complex phenomenon that has been studied extensively over the centuries, and it continues to fascinate scientists and researchers to this day. Sample Result - Pets For my second test, I started with a basic prompt and then a better version that asked for specific types of details: (Quick editorial note - the tabular data below is a bit messy, but was messy in the original output.) not Prompt: why are cats so much better than dogs? Cats and dogs are both popular pets, and there is no definitive answer to the question of which one is better. Both cats and dogs have their own unique set of advantages and disadvantages, and the best pet for you will depend on your individual needs and preferences. Some people prefer cats because they are generally more independent than dogs. Cats are typically happy to entertain themselves, and they don't need to be walked or taken outside for exercise. This can be a big advantage for people who live in apartments or who have busy schedules. Cats are also known for being clean and tidy animals. They groom themselves regularly, and they typically use the litter box without any problems. This can be a big advantage for people who don't want to deal with the mess and smell of a dog. Of course, there are also some disadvantages to having a cat. Cats can be more expensive than dogs, and they can be more difficult to train. Cats are also more likely to scratch furniture and other household items. Ultimately, the decision of whether to get a cat or a dog is a personal one. There is no right or wrong answer, and the best pet for you will depend on your individual needs and preferences. Here is a table summarizing the key differences between cats and dogs: Characteristic Cat Dog Independence More independent Less independent Exercise needs Does not need to be walked or taken outside Needs to be walked or taken outside Cleanliness Cleans itself regularly Needs to be bathed regularly Training Can be difficult to train Easier to train Scratching May scratch furniture and other household items Does not typically scratch furniture Cost More expensive Less expensive Prompt: why are cats so much better than dogs? explain with a bulleted list of reasons that cover emotional well being and financial aspects Emotional well-being: Independence: Cats are more independent than dogs, which can be a good thing for people who want a pet that doesn't require a lot of attention. Low maintenance: Cats are generally lower maintenance than dogs. They don't need to be walked or groomed as often, and they can be left alone for longer periods of time. Quiet: Cats are generally quieter than dogs, which can be ideal for people who live in apartments or have noise-sensitive neighbors. Therapeutic: Studies have shown that cats can have a calming effect on humans, and they can help to reduce stress and anxiety. Financial aspects: Lower cost: Cats are generally less expensive to own than dogs. They eat less food, they need fewer vet visits, and they don't require as much grooming. Easier to travel with: Cats are easier to travel with than dogs. They can be transported in a carrier, and they don't need to be walked or exercised while you're away. Longer lifespan: Cats have a longer lifespan than dogs, on average. This means that you can enjoy your cat's companionship for many years to come. Sample Result - Chain of Thought Prompting The following test came from an presentation from AWS re:Invent: . I found a lot of great advice from this session, including a good overview of Chain of Thought prompting, where the idea is you provide information about the steps used to solve a problem to help the GenAI engine better solve a prompt. excellent AWS re:Invent 2023 - Prompt engineering best practices for LLMs on Amazon Bedrock (AIM377) Now, the example given in that presentation went like so: Q: Roger has 5 tennis balls. he buys 2 more cans of tennis balls. Each 
can has 3 tennis balls. How many tennis balls does he have now?

A: The answer is 11.

Q. The cafeteria had 23 apples. If they used 20 to make lunch and 
bought 6 more, how many apples do they have? In the presentation, the model in use incorrectly returned 27. In my test, it worked correctly, but I absolutely saw issues with math back when I built my last November. generative AI blackjack advice demo As I said, Gemini handled it fine: But in Prompt Tester, I tried the suggested CoT prompt: A: The answer is 9. Q: Roger has 5 tennis balls. he buys 2 more cans of tennis balls. Each 
can has 3 tennis balls. How many tennis balls does he have now?

A: Roger started with 5 balls. 2 cans of 3 tennis balls each is 6 
tennis balls. 5 + 6 = 11. The answer is 11.

Q. The cafeteria had 23 apples. If they used 20 to make lunch and 
bought 6 more, how many apples do they have? And the result was improved, showing how it got to the answer: A: The cafeteria had 23 apples. They used 20 apples for lunch, which 
means they have 3 apples left. They then bought 6 more apples, so 
they now have a total of 3 + 6 = 9 apples.

The answer is 9. The difference is pretty significant. The Code If this seems useful to you at all, feel free to grab the code from here: . As I mentioned, it shouldn't be that difficult to add or some such and use a different service. If you do, let me know! https://github.com/cfjedimaster/ai-testingzone/tree/main/prompt_tester callChatGPT

How to Test Multiple Variations of Generative AI Prompts

জেনারেটিভ এআই প্রম্পটগুলির একাধিক বৈচিত্র কীভাবে পরীক্ষা করবেন

So testen Sie mehrere Variationen generativer KI-Eingabeaufforderungen

Cómo probar múltiples variaciones de indicaciones de IA generativa

Comment tester plusieurs variantes d'invites d'IA générative

जेनरेटिव एआई प्रॉम्प्ट के एकाधिक विविधताओं का परीक्षण कैसे करें

生成 AI プロンプトの複数のバリエーションをテストする方法

Generative AI 프롬프트의 다양한 변형을 테스트하는 방법

Como testar múltiplas variações de prompts de IA generativos

Как протестировать несколько вариантов подсказок генеративного ИИ

Üretken Yapay Zeka İstemlerinin Çoklu Varyasyonlarını Test Etme

Cách kiểm tra nhiều biến thể của lời nhắc AI sáng tạo

如何测试生成式 AI 提示的多种变体

Out of all the VR accessories and peripherals I’ve tested, one item type stands out not for its flashy tech or game-changing mechanics, but for its fundamental simplicity and utter indispensability. That item is the charging stand/dock. I know what you’re thinking, “Really? A charging stand?” But hear me out. After reviewing a ton of VR accessories, from the immersive to the fantastic , it's this unassuming piece of tech that's become my daily driver. Why? Because it tackles : keeping your VR headset organized, charged, and ready to go. haptic feedback vests Darth Maul Beatsaber Mod the most mundane yet critical aspect of VR gaming The RGB Vertical Charging Stand by KIWI doesn’t just promise to keep your Quest 3 and controllers from becoming another piece of clutter on your desk or a tripping hazard on your floor. It charges both the headset and battery strap simultaneously to ensure that you never have to worry about running out of headset battery ever again. Let’s dive deep into the specs, design, functionality, and cost comparison of the KIWI RGB Vertical Charging Stand to see if it lives up to the hype. I have not been paid to write this review. However, KIWI Design sent me this item for free to test for this article. Disclaimer: Table of Contents: Specs Design functionality Cost Specs - The Nitty-Gritty Jumping into the heart of the KIWI RGB Vertical Charging Stand, let's review the specs. The stand comes in at a comfortable 3.92 pounds. It isn't just a lightweight contender in the world of VR accessories. It's got enough heft to stay put, even when you're in a rush to grab your headset and jump into another VR adventure. Weight: Standing at 12.05 x 8.66 x 4.29 inches, it's clear the KIWI team put some serious thought into making a stand that's just the right size. It's compact enough not to hog all your desk space but large enough to securely hold your Meta Quest 2/Quest 3/Quest Pro. Dimensions: Certified with the “Made for Meta” seal of approval, this stand is tailor-made to fit the 2, Quest 3, and Quest Pro like a glove, ensuring your headset is always cradled securely and charged up without any fuss. I had no problems setting this up and it’s completely intuitive to use. Compatibility: Meta Quest Crafted with care, the stand's materials feel premium to the touch, echoing the quality of your VR headset. Cloaked in an elegant shade of black, it’s a piece that doesn’t just scream high tech; it whispers sophistication. If you were lucky enough to buy the first-ever Oculus Quest, you probably remember the velvet touch of the box. Material & Color: The care would put into every aspect of design, packaging, and feel. Opening up this dock gave me a nostalgic feeling that I’ve been missing since Meta took over. Their builds are flimsy that require you to spend extra money to replace their crappy head strap that they know everyone is going to replace. KIWI definitely puts in attention to detail that Meta could learn alot from. Oculus Here’s the most important piece of this stand. With a magnetic USB Type-C connector, this stand makes charging your headset as easy as dropping it into place. Charging Capabilities: No fumbling with cables or ports; just set it and forget it. The stand singularly focuses on powering up your headset, making sure it’s always ready for your next gaming sesh. Warranty - Peace of Mind Included Another important note is that the item comes with a 24-month warranty from the date of purchase to ensure your investment is protected. It’s a nod to their confidence in the product's quality and their commitment to your satisfaction. Design First off, I really like how the design looks sleek and modern. It's got that look that meshes well with the rest of your VR setup, which is pretty much what you want if you’re aiming to keep your gaming space feeling more like a high-tech haven and less like a tech junkyard. The stand doesn't scream for attention but rather coolly nods from the corner of the room. And I can’t reiterate enough: it keeps your headset and controllers clean and tidy. Quality Handling this stand, it’s clear we’re not talking about some run-of-the-mill, churned-out-in-mass accessory. There’s a heft and a finish to it that you won’t find on those too-good-to-be-true deals on AliExpress or Wish. It's reassuring to know that in a market flooded with cheap knock-offs, there are still companies putting effort into quality. Space Saver The real MVP feature of its design has to be the form factor. KIWI’s got the right idea making this stand vertical. Space is a premium, especially on gamers' desks, which are already battling for real estate between monitors, keyboards, and that ever-growing collection of gaming memorabilia. The stand keeps your Quest 3 and controllers neatly stacked, charging, and out of the way, making it a solid ally in the fight against clutter. RGB I’m not one of those gamers who care about lights on my setup. But if you are one of those people, it comes with a multi-color RGB light band that does add a nice colorful element to it. It is called the “RGB Vertical Charging Stand” after all. Functionality Alright, let's dive into what this KIWI RGB Vertical Charging Stand actually does, beyond just looking pretty on your desk. Docking Function First up, the stand does the basics right: it holds two controllers and your headset. This might not sound like rocket science, but in the grand scheme of things, having a dedicated spot for your VR gear is a game-changer. No more leaving your controllers in random places only to forget where you put them. Or worse, finding your headset has been sitting under a pile of clothes (this has literally happened to me multiple times). Everything has its place, and that peace of mind alone is worth the money if you have the budget for it. Charging Function Now, onto the main act: charging your headset. You dock it, and it charges - no fumbling with cables or trying to align ports. It's all magnetic, making it as close to magic as we're gonna get. Just drop your headset in, and it takes care of the rest. It's like having a pit stop in your room where your gear gets prepped and ready without you having to lift a finger. Well, maybe just a little to place it on the stand. The Kiwi SPC Battery Strap Compatibility: The Necessary Cherry on Top If you've got the , this stand becomes even more of a powerhouse. One of my is that their design didn’t take into account battery straps. Kiwi SPC battery strap main issues with the ZyberVR Quest 2 dock To charge the headset in the dock, you input a custom magnetic connector into the headset. However, to use your battery headstrap and keep the headset charged while playing, you need to connect the battery back to the headset via a usb-c cable. So it’d be SUPER ANNOYING to have to unplug the custom connector and plug in your battery strap to the headset every ime you play. Kiwi solved that problem perfectly. Hook up your headset with the SPC strap attached, and the stand figures out how to charge both, prioritizing the headset first. Once that's full, it starts powering up the headstrap. It's a neat little feature that shows some genuine thought went into how to make your VR life a tad easier. It means longer play sessions without the “Oops, I forgot to charge my headstrap” moments. Cost Comparison Alright, diving into the price comparison, , putting it neck and neck with ZyberVR's stand, priced slightly lower at $63.99. Both are contenders in the VR accessory arena. the KIWI RGB Vertical Charging Stand is tagged at $69.99 ZyberVR sweetens the deal with rechargeable batteries for your controllers, offering a tangible extra bang for your buck. It's a solid perk, especially if the thought of buying batteries is a hassle you'd rather avoid. On the flip side, KIWI focuses instead on seamless integration with their SPC battery headstrap. This allows for a single-cable solution to charge both your headset and the headstrap simultaneously, streamlining your setup and cutting down on cable clutter. So, what's the verdict? If controller batteries are your main concern, ZyberVR might edge out ahead. But for those invested in a tidy, one-cable charging setup, KIWI's offering is the way to go. It boils down to what matters most to you: extra batteries in the box or a cleaner, simpler charging experience. Either way, you're getting a product aimed at making VR gaming a bit more convenient. Final Verdict: 8/10 Wrapping this up, let's talk bottom line. Between the sleek black finish of the KIWI RGB Vertical Charging Stand and ZyberVR's white counterpart, my vote leans towards KIWI for its aesthetics. There's something about that dark, sleek design that just vibes better with the rest of my setup. Now, value-wise, ZyberVR does toss in a sweet deal with those rechargeable batteries for the controllers. That's a hard perk to overlook, especially if you're all about getting the most bang for your buck right out of the box. But KIWI's got its own ace with that one-cable solution, not just keeping your setup looking clean but also showing off some serious thought went into the user experience. Being able to charge the headset and a battery strap together without turning your desk into a wire nest? That's pretty slick. Sure, not having a direct charge option for the controllers with KIWI's stand is a hiccup. Yet, it's not the kind of dealbreaker that would push me away from recommending it. Especially when you weigh it against the convenience and design thoughtfulness it brings to the table. For $69.99, I'm leaning hard into recommending the KIWI RGB Vertical Charging Stand. It's not just another piece of gear; it's become an essential part of my daily VR ritual—keeping my gaming space organized and ensuring my headset is always charged up and ready to roll. For anyone deep into their Quest experience, this stand is a solid investment that pays off in both functionality and aesthetics.

KIWI Design Quest 3 RGB Vertical Charging Stand Review: Comparing Cost and Functions

KIWI ডিজাইন কোয়েস্ট 3 RGB উল্লম্ব চার্জিং স্ট্যান্ড পর্যালোচনা: খরচ এবং ফাংশন তুলনা

Testbericht zum vertikalen Ladeständer KIWI Design Quest 3 RGB: Kosten und Funktionen im Vergleich

Revisión del soporte de carga vertical KIWI Design Quest 3 RGB: comparación de costos y funciones

Examen du support de charge vertical KIWI Design Quest 3 RGB : comparaison des coûts et des fonctions

KIWI डिज़ाइन क्वेस्ट 3 RGB वर्टिकल चार्जिंग स्टैंड समीक्षा: लागत और कार्यों की तुलना

KIWI Design Quest 3 RGB縦型充電スタンドレビュー：コストと機能を比較

KIWI Design Quest 3 RGB 수직 충전 스탠드 검토: 비용 및 기능 비교

Análise do suporte de carregamento vertical KIWI Design Quest 3 RGB: Comparando custos e funções

Обзор вертикальной подставки для зарядки KIWI Design Quest 3 RGB: сравнение стоимости и функций

KIWI Design Quest 3 RGB Dikey Şarj Standı İncelemesi: Maliyet ve İşlevlerin Karşılaştırılması

Đánh giá đế sạc dọc KIWI Design Quest 3 RGB: So sánh chi phí và chức năng

KIWI Design Quest 3 RGB立式充电座评测：成本与功能比较

This tutorial shows you how to deploy and automate a Docker container using Pulumi in Google Cloud Platform's Cloud Run with minimum permissions. Here's the GitHub Repository for reference: https://github.com/superjose/deploy-to-cloud-run-go Get the CLIs: . Create a Google Cloud Account Install Google Cloud CLI Install Pulumi CLI - We need it to build the Docker container. Install Docker Bootstrap the project: Create a directory: pulumi mkdir pulumi Run to initialize a pulumi project with Go (It can be your language of choice pulumi new go Navigate to the directory. pulumi cd pulumi Navigate to and create a new project. cloud.google.com Take note of the (Usually the project's name). project-id Generate the necessary permissions using gcloud CLI Login with the Google Auth CLI: gcloud auth login (Optional) Set the project in google cloud CLI (Can be changed anytime). This saves you from passing into every command. --project [PROJECT-ID] gcloud If your machine has multiple GCP projects, skip this step and pass the flag into every command. --project gcloud Create a service account (The account that Pulumi will connect to): gcloud iam service-accounts create pulumi-gcp --description="Pulumi GCP" Download the credentials for the service accounts and store them locally (Remember to replace with your GCP Project Id): [PROJECT-ID] gcloud iam service-accounts keys create ~/keys/gcp/pulumi-service-account-key-file.json --iam-account=pulumi-gcp@[PROJECT-ID].iam.gserviceaccount.com Set Pulumi's gcp credentials config path:
(This will connect the service account with Pulumi) pulumi config set gcp:credentials ~/keys/gcp/pulumi-service-account-key-file.json Set the GCP Project by doing: pulumi config set gcp:project [PROJECT-ID] Create a file (Inside the dir) and add the required permissions in : roles.gcp.yml pulumi includedPermissions # https://cloud.google.com/iam/docs/creating-custom-roles#creating
# Yaml to define the Pulumi GCP Roles that need to be created with gcloud CLI
title: Pulumi GCP Roles
description: |
  This policy ensures that all GCP roles are created using Pulumi.
stage: GA
# https://cloud.google.com/iam/docs/permissions-reference
includedPermissions:
  - serviceusage.services.list
  - serviceusage.services.enable
  - serviceusage.services.disable
  - serviceusage.services.get
  - serviceusage.services.use
    # Permissions for GCR
  - storage.objects.create
  - storage.objects.delete # Optional: only include if you need to delete images
  - storage.objects.get
  # Permissions for Google Artifact Registry
  - artifactregistry.repositories.create
  - artifactregistry.repositories.delete
  - artifactregistry.repositories.get
  - artifactregistry.repositories.list
  - artifactregistry.repositories.update
  - artifactregistry.repositories.downloadArtifacts
  - artifactregistry.repositories.uploadArtifacts
  - artifactregistry.repositories.deleteArtifacts
  # Permissions
  # Permissions
  - run.services.create
  - run.services.get
  - run.services.list
  - run.services.update
  - run.services.delete
  - run.services.getIamPolicy
  - run.services.setIamPolicy
  - iam.serviceAccounts.actAs
# NOTE: This should be removed the first time you're creating a role.
# This etag is to update the current active role (As GCP lets you manage multiple roles)
# I'm commenting it out so I can always replace the role
# etag: BwYS74Xx5y4= Create the with the file above:
(We assume we're running this code from the directory) pulumi_admin_role pulumi gcloud iam roles create pulumi_admin_role --project=[PROJECT-ID] --file='./roles.gcp.yml' In case you need to make edits, change the file and use: gcloud iam roles update pulumi_admin_role --project=[PROJECT-ID] --file='./roles.gcp.yml' We're also adding the role (I haven't found a better way) (Otherwise we'd get 403 errors when refreshing and updating in Pulumi)<sup>1</sup> serviceAccountAdmin gcloud projects add-iam-policy-binding [PROJECT-ID] --role roles/iam.serviceAccountAdmin   --member serviceAccount:pulumi-gcp@[PROJECT-ID].iam.gserviceaccount.com (The following will add the new role to the service account) gcloud projects add-iam-policy-binding [PROJECT-ID] --role projects/[PROJECT-ID]/roles/pulumi_admin_role   --member serviceAccount:pulumi-gcp@[PROJECT-ID].iam.gserviceaccount.com Our in the directory:
(Check the code for comments!) main.go pulumi We enable the required services (Artifact Registry, and Cloud Run). Artifact Registry is used to host the docker container image. Cloud Runner will launch the Docker image from Artifact Registry. We build the docker image locally (We specify the platform in case you're using an ARM chip like M1, M2, Snapdragon SQ, X Elite, etc.) We create a chain of "DependsOn" to notify Pulumi:
5.1 Services need to be enabled first
5.2 We create the Artifact Repository
5.3 We build the docker image and push it to Artifact Registry.
5.4 We pull the Docker Image from Artifact Registry and run it.
5.5 We add IAM permissions so it can be accessed from anywhere. package main

import (
	"errors"
	"log"
	"os"

	"github.com/joho/godotenv"
	"github.com/pulumi/pulumi-docker/sdk/v3/go/docker"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/artifactregistry"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudrun"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/projects"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// This is the name you created in Google Cloud Platform (GCP).
const gcpProjectId = "deploy-to-cloud-run-go"

// The Docker Image Name
const dockerImageName = "my-app-docker"
const artifactRegistryServiceName = "artifact-registry-api"
const artifactRegistryRepoName = "my-app-artifact-repo"
const artifactRegistryRepoLocation = "us-east1"
const cloudRunAdminServiceName = "cloud-run-admin-service"
const cloudRunServiceName = "cloud-run-service"

// For more info: https://cloud.google.com/run/docs/locations
const cloudRunLocation = "us-east1"

// The tag for the Docker image
const imageTag = "latest"

// This is a url like: us-east1-docker.pkg.dev
// It is used to push the Docker image to Google Container Registry
// For more info: https://cloud.google.com/container-registry/docs/pushing-and-pulling
// The format is: <region>-docker.pkg.dev
var dockerGCPServer = cloudRunLocation + "-docker.pkg.dev"

// The full path to the Docker image
// It is used to deploy the Docker image to Google Cloud Run
// The format is: <region>-docker.pkg.dev/<project-id>/<repo-name>/<image-name>:<tag>
// For more info: https://cloud.google.com/run/docs/deploying
// Example: us-east1-docker.pkg.dev/deploy-to-cloud-run-go/my-app--artifact-repo/my-app-docker:latest
var dockerImageWithPath = dockerGCPServer + "/" + gcpProjectId + "/" + artifactRegistryRepoName + "/" + dockerImageName + ":" + imageTag

func main() {

	// Load the .env file
	err := godotenv.Load()

	if err != nil {
		log.Fatal("Error loading .env file")
	}

	pulumi.Run(func(ctx *pulumi.Context) error {

		enabledServices, serviceResultErr := enableServices(ctx)

		if serviceResultErr != nil {
			return serviceResultErr
		}

		artifactRegistryRepo, createArtifactErr := createArtifactRegistryNewRepository(ctx, &enabledServices)
		if createArtifactErr != nil {
			return createArtifactErr
		}

		dockerImage, buildAndPushErr := buildAndPushToContainerRegistry(ctx, &enabledServices, artifactRegistryRepo)

		if buildAndPushErr != nil {
			return buildAndPushErr
		}

		deployContainerErr := deployContainerToCloudRun(ctx, &enabledServices, dockerImage)

		if deployContainerErr != nil {
			return deployContainerErr
		}

		return nil
	})
}

type EnabledServices struct {
	CloudRunService         *projects.Service `pulumi:"cloudRunService"`
	ArtifactRegistryService *projects.Service `pulumi:"artifactRegistryService"`
}

func enableServices(ctx *pulumi.Context) (EnabledServices, error) {

	cloudRunService, cloudRunAdminErr := projects.NewService(ctx, cloudRunAdminServiceName, &projects.ServiceArgs{
		Service: pulumi.String("run.googleapis.com"),
		Project: pulumi.String(gcpProjectId),
	})

	if cloudRunAdminErr != nil {
		return EnabledServices{}, cloudRunAdminErr
	}

	artifactRegistryService, err := projects.NewService(ctx, artifactRegistryServiceName, &projects.ServiceArgs{
		Service: pulumi.String("artifactregistry.googleapis.com"),
	})

	if err != nil {
		return EnabledServices{}, err
	}
	return EnabledServices{
		CloudRunService:         cloudRunService,
		ArtifactRegistryService: artifactRegistryService,
	}, nil
}

func createArtifactRegistryNewRepository(ctx *pulumi.Context, enabledServices *EnabledServices) (*artifactregistry.Repository, error) {

	if enabledServices == nil || enabledServices.ArtifactRegistryService == nil {
		return nil, errors.New("enabledServices cannot be nil")
	}

	dependingResources := []pulumi.Resource{
		enabledServices.ArtifactRegistryService,
	}

	repo, err := artifactregistry.NewRepository(ctx, artifactRegistryRepoName, &artifactregistry.RepositoryArgs{
		Location:     pulumi.String(artifactRegistryRepoLocation),
		RepositoryId: pulumi.String(artifactRegistryRepoName),
		Format:       pulumi.String("DOCKER"),
		Description:  pulumi.String("The repository that will hold social-log Docker images."),
	}, pulumi.DependsOn(dependingResources))

	if err != nil {
		return nil, err
	}

	return repo, nil
}

func buildAndPushToContainerRegistry(ctx *pulumi.Context, enabledServices *EnabledServices, artifactRegistryRepo *artifactregistry.Repository) (*docker.Image, error) {

	if enabledServices == nil || enabledServices.ArtifactRegistryService == nil {
		return nil, errors.New("enabledServices cannot be nil")
	}

	if artifactRegistryRepo == nil {
		return nil, errors.New("artifactRegistryRepo cannot be nil")
	}

	// Lookup GOOGLE_CREDENTIALS environment variable which should hold the path to the JSON key file
	jsonKeyPath, present := os.LookupEnv("GOOGLE_CREDENTIALS_FILE_PATH")
	if !present {
		return nil, errors.New("GOOGLE_CREDENTIALS_FILE_PATH environment variable is not set")
	}

	// Read the JSON key file
	jsonKey, err := os.ReadFile(jsonKeyPath)
	if err != nil {
		return nil, err
	}

	dependingSources := []pulumi.Resource{
		enabledServices.ArtifactRegistryService,
		artifactRegistryRepo,
	}

	// Build and push Docker image to Google Container Registry using the JSON key
	image, err := docker.NewImage(ctx, dockerImageName, &docker.ImageArgs{
		Build: &docker.DockerBuildArgs{
			Context: pulumi.String("../"), // Adjust the context according to your project structure

			ExtraOptions: pulumi.StringArray{
				// This option is needed for devices running on ARM architecture, such as Apple M1/M2/MX CPUs
				pulumi.String("--platform=linux/amd64"),
			},
		},
		ImageName: pulumi.String(dockerImageWithPath),
		Registry: &docker.ImageRegistryArgs{
			Server:   pulumi.String(dockerGCPServer),
			Username: pulumi.String("_json_key"),     // Special username for GCP
			Password: pulumi.String(string(jsonKey)), // Provide the contents of the key file
		},
	}, pulumi.DependsOn(dependingSources))
	if err != nil {
		return nil, err
	}

	return image, nil
}

func deployContainerToCloudRun(ctx *pulumi.Context, enabledServices *EnabledServices, dockerImage *docker.Image) error {

	if enabledServices == nil || enabledServices.CloudRunService == nil {
		return errors.New("enabledServices cannot be nil")
	}

	if dockerImage == nil {
		return errors.New("dockerImage cannot be nil")
	}

	dependingSources := []pulumi.Resource{
		enabledServices.CloudRunService,
		dockerImage,
	}

	appService, err := cloudrun.NewService(ctx, cloudRunServiceName, &cloudrun.ServiceArgs{
		Location: pulumi.String(cloudRunLocation), // Choose the appropriate region for your service
		Template: &cloudrun.ServiceTemplateArgs{
			Spec: &cloudrun.ServiceTemplateSpecArgs{
				Containers: cloudrun.ServiceTemplateSpecContainerArray{
					&cloudrun.ServiceTemplateSpecContainerArgs{
						Image: dockerImage.ImageName,
						Resources: &cloudrun.ServiceTemplateSpecContainerResourcesArgs{
							Limits: pulumi.StringMap{
								"memory": pulumi.String("256Mi"), // Adjust the memory limit as needed
							},
						},
					},
				},
			},
		},
		Traffics: cloudrun.ServiceTrafficArray{
			&cloudrun.ServiceTrafficArgs{
				Percent:        pulumi.Int(100),
				LatestRevision: pulumi.Bool(true),
			},
		},
	}, pulumi.DependsOn(dependingSources))

	if err != nil {
		return err
	}

	_, iamErr := cloudrun.NewIamMember(ctx, "invoker", &cloudrun.IamMemberArgs{
		Service:  appService.Name,
		Location: appService.Location,
		Role:     pulumi.String("roles/run.invoker"),
		Member:   pulumi.String("allUsers"),
	})

	if iamErr != nil {
		return iamErr
	}

	ctx.Export("containerUrl", appService.Statuses.Index(pulumi.Int(0)).Url().ToOutput(ctx.Context()))
	return nil
} Update the in your Dockerfile:
There's a , and in which you need to export your environment variable to ENV known issue here HOME /root # Set the ENV HOME before your ENTRYPOINT.
ENV HOME=/root

# This is specific to your project. 
ENTRYPOINT ["/whatever-is-your-entrypoint"] Create a .env file in the pulumi directory: Set the * to the one you saved on full path 11) GOOGLE_CREDENTIALS_FILE_PATH="/Users/myusername/keys/gcp/pulumi-service-account-key-file.json" Run pulumi up You should be up and running! Extras The go.mod module social-log-go

go 1.21

toolchain go1.22.0

require (
	github.com/pulumi/pulumi-gcp/sdk/v7 v7.11.2
	github.com/pulumi/pulumi/sdk/v3 v3.108.1
)

require (
	dario.cat/mergo v1.0.0 // indirect
	github.com/Masterminds/semver v1.5.0 // indirect
	github.com/Microsoft/go-winio v0.6.1 // indirect
	github.com/ProtonMail/go-crypto v0.0.0-20230828082145-3c4c8a2d2371 // indirect
	github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da // indirect
	github.com/agext/levenshtein v1.2.3 // indirect
	github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
	github.com/atotto/clipboard v0.1.4 // indirect
	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
	github.com/blang/semver v3.5.1+incompatible // indirect
	github.com/charmbracelet/bubbles v0.16.1 // indirect
	github.com/charmbracelet/bubbletea v0.24.2 // indirect
	github.com/charmbracelet/lipgloss v0.7.1 // indirect
	github.com/cheggaaa/pb v1.0.29 // indirect
	github.com/cloudflare/circl v1.3.7 // indirect
	github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect
	github.com/cyphar/filepath-securejoin v0.2.4 // indirect
	github.com/djherbis/times v1.5.0 // indirect
	github.com/emirpasic/gods v1.18.1 // indirect
	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
	github.com/go-git/go-billy/v5 v5.5.0 // indirect
	github.com/go-git/go-git/v5 v5.11.0 // indirect
	github.com/gogo/protobuf v1.3.2 // indirect
	github.com/golang/glog v1.1.0 // indirect
	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
	github.com/golang/protobuf v1.5.3 // indirect
	github.com/google/uuid v1.3.0 // indirect
	github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645 // indirect
	github.com/hashicorp/errwrap v1.1.0 // indirect
	github.com/hashicorp/go-multierror v1.1.1 // indirect
	github.com/hashicorp/hcl/v2 v2.17.0 // indirect
	github.com/inconshreveable/mousetrap v1.1.0 // indirect
	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
	github.com/joho/godotenv v1.5.1 // indirect
	github.com/kevinburke/ssh_config v1.2.0 // indirect
	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
	github.com/mattn/go-isatty v0.0.19 // indirect
	github.com/mattn/go-localereader v0.0.1 // indirect
	github.com/mattn/go-runewidth v0.0.15 // indirect
	github.com/mitchellh/go-ps v1.0.0 // indirect
	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
	github.com/muesli/cancelreader v0.2.2 // indirect
	github.com/muesli/reflow v0.3.0 // indirect
	github.com/muesli/termenv v0.15.2 // indirect
	github.com/opentracing/basictracer-go v1.1.0 // indirect
	github.com/opentracing/opentracing-go v1.2.0 // indirect
	github.com/pgavlin/fx v0.1.6 // indirect
	github.com/pjbgf/sha1cd v0.3.0 // indirect
	github.com/pkg/errors v0.9.1 // indirect
	github.com/pkg/term v1.1.0 // indirect
	github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231 // indirect
	github.com/pulumi/esc v0.6.2 // indirect
	github.com/pulumi/pulumi-docker/sdk/v3 v3.6.1 // indirect
	github.com/rivo/uniseg v0.4.4 // indirect
	github.com/rogpeppe/go-internal v1.11.0 // indirect
	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 // indirect
	github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 // indirect
	github.com/sergi/go-diff v1.3.1 // indirect
	github.com/skeema/knownhosts v1.2.1 // indirect
	github.com/spf13/cobra v1.7.0 // indirect
	github.com/spf13/pflag v1.0.5 // indirect
	github.com/texttheater/golang-levenshtein v1.0.1 // indirect
	github.com/tweekmonster/luser v0.0.0-20161003172636-3fa38070dbd7 // indirect
	github.com/uber/jaeger-client-go v2.30.0+incompatible // indirect
	github.com/uber/jaeger-lib v2.4.1+incompatible // indirect
	github.com/xanzy/ssh-agent v0.3.3 // indirect
	github.com/zclconf/go-cty v1.13.2 // indirect
	go.uber.org/atomic v1.9.0 // indirect
	golang.org/x/crypto v0.17.0 // indirect
	golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect
	golang.org/x/mod v0.14.0 // indirect
	golang.org/x/net v0.19.0 // indirect
	golang.org/x/sync v0.5.0 // indirect
	golang.org/x/sys v0.15.0 // indirect
	golang.org/x/term v0.15.0 // indirect
	golang.org/x/text v0.14.0 // indirect
	golang.org/x/tools v0.15.0 // indirect
	google.golang.org/genproto/googleapis/rpc v0.0.0-20230706204954-ccb25ca9f130 // indirect
	google.golang.org/grpc v1.57.1 // indirect
	google.golang.org/protobuf v1.31.0 // indirect
	gopkg.in/warnings.v0 v0.1.2 // indirect
	gopkg.in/yaml.v3 v3.0.1 // indirect
	lukechampine.com/frand v1.4.2 // indirect
) If you include this Run , and this will fetch all the packages for you go.mod go tidy Footnotes I fought against permissions for 5 days. The predefined GCP role brought in the additional permissions needed. 1* serviceAccountAdmin

Automate and Deploy a Docker Container to Google Cloud Run from Scratch Using Pulumi and Go

Authors: (1) Michael Sorochan Armstrong, Computational Data Science (CoDaS) Lab in the Department of Signal Theory, Telematics, and Communications at the University of Granada; (2) Jose Carlos P´erez-Gir´on, part of the Interuniversity Institute for Research on the Earth System in Andalucia through the University of Granada; (3) Jos´e Camacho, Computational Data Science (CoDaS) Lab in the Department of Signal Theory, Telematics, and Communications at the University of Granada; (4) Regino Zamora, part of the Interuniversity Institute for Research on the Earth System in Andalucia through the University of Granada. Table of Links Abstract & Introduction Optimization of the Optical Interpolation Materials and Methods Results and Discussion Conclusion Appendix A: Proof of Hermitian Self-Adjoint product identity for Equidistant Time-Domain Measurements Appendix B: AAH ̸= MIN I in the Non-Equidistant Case Acknowledgments & References ACKNOWLEDGMENTS The proof for the equidistant case was adapted from a proof by David J. Fleet and Allan D. Jepson from the University of Toronto [18]. REFERENCES [1] C. Haley, “Missing-data nonparametric coherency estimation,” IEEE Signal Processing Letters, vol. 28, pp. 1704–1708, 2021. [2] S. Dilmaghani, I. C. Henry, P. Soonthornnonda, E. R. Christensen, and R. C. Henry, “Harmonic analysis of environmental time series with missing data or irregular sample spacing,” Environmental science & technology, vol. 41, no. 20, pp. 7030–7038, 2007. [3] J. W. Cooley and J. W. Tukey, “An algorithm for the machine calculation of complex fourier series,” Mathematics of computation, vol. 19, no. 90, pp. 297–301, 1965. [4] F. Rasheed, P. Peng, R. Alhajj, and J. Rokne, “Fourier transform based spatial outlier mining,” in Intelligent Data Engineering and Automated Learning-IDEAL 2009: 10th International Conference, Burgos, Spain, September 23-26, 2009. Proceedings 10. Springer, 2009, pp. 317–324. [5] C. Van Loan, Computational frameworks for the fast Fourier transform. SIAM, 1992. [6] H. Carslaw, “A historical note on gibbs’ phenomenon in fourier’s series and integrals,” Bulletin of the American Mathematical Society, 1925. [7] J. Markel, “Fft pruning,” IEEE transactions on Audio and Electroacoustics, vol. 19, no. 4, pp. 305–311, 1971. [8] J. C. Bowman and Z. Ghoggali, “The partial fast fourier transform,” Journal of Scientific Computing, vol. 76, pp. 1578–1593, 2018. [9] M. Kircheis and D. Potts, “Direct inversion of the nonequispaced fast fourier transform,” Linear Algebra and its Applications, vol. 575, pp. 106–140, 2019. [10] S. Kunis and D. Potts, “Stability results for scattered data interpolation by trigonometric polynomials,” SIAM Journal on Scientific Computing, vol. 29, no. 4, pp. 1403–1419, 2007. [11] K. B. Petersen, M. S. Pedersen et al., “The matrix cookbook,” Technical University of Denmark, vol. 7, no. 15, p. 510, 2008. [12] C. M. Bishop, Neural networks for pattern recognition. Oxford university press, 1995. [13] H. Wickham, M. Averick, J. Bryan, W. Chang, L. D. McGowan, R. Franc¸ois, G. Grolemund, A. Hayes, L. Henry, J. Hester, M. Kuhn, T. L. Pedersen, E. Miller, S. M. Bache, K. Muller, J. Ooms, D. Robin- ¨ son, D. P. Seidel, V. Spinu, K. Takahashi, D. Vaughan, C. Wilke, K. Woo, and H. Yutani, “Welcome to the tidyverse,” Journal of Open Source Software, vol. 4, no. 43, p. 1686, 2019. [14] R Core Team, R: A Language and Environment for Statistical Computing, R Foundation for Statistical Computing, Vienna, Austria, 2023. [Online]. Available: https://www.R-project.org/ [15] C. R. Harris, K. J. Millman, S. J. van der Walt, R. Gommers, P. Virtanen, D. Cournapeau, E. Wieser, J. Taylor, S. Berg, N. J. Smith, R. Kern, M. Picus, S. Hoyer, M. H. van Kerkwijk, M. Brett, A. Haldane, J. F. del R´ıo, M. Wiebe, P. Peterson, P. Gerard-Marchant, K. Sheppard, T. Reddy, W. Weckesser, ´ H. Abbasi, C. Gohlke, and T. E. Oliphant, “Array programming with NumPy,” Nature, vol. 585, no. 7825, pp. 357–362, Sep. 2020. [Online]. Available: https://doi.org/10.1038/s41586-020-2649-2 [16] P. Virtanen, R. Gommers, T. E. Oliphant, M. Haberland, T. Reddy, D. Cournapeau, E. Burovski, P. Peterson, W. Weckesser, J. Bright, S. J. van der Walt, M. Brett, J. Wilson, K. J. Millman, N. Mayorov, A. R. J. Nelson, E. Jones, R. Kern, E. Larson, C. J. Carey, ˙I. Polat, Y. Feng, E. W. Moore, J. VanderPlas, D. Laxalde, J. Perktold, R. Cimrman, I. Henriksen, E. A. Quintero, C. R. Harris, A. M. Archibald, A. H. Ribeiro, F. Pedregosa, P. van Mulbregt, and SciPy 1.0 Contributors, “SciPy 1.0: Fundamental Algorithms for Scientific Computing in Python,” Nature Methods, vol. 17, pp. 261– 272, 2020. [17] J. D. Hunter, “Matplotlib: A 2d graphics environment,” Computing in Science & Engineering, vol. 9, no. 3, pp. 90–95, 2007. [18] “Notes on fourier analysis,” http://www.cs.toronto.edu/ ∼jepson/csc320/notes/fourier.pdf, accessed: 2023-09-01. This paper is under CC 4.0 license. available on arxiv

Groundbreaking Research in Signal Theory

Authors: (1) Michael Sorochan Armstrong, Computational Data Science (CoDaS) Lab in the Department of Signal Theory, Telematics, and Communications at the University of Granada; (2) Jose Carlos P´erez-Gir´on, part of the Interuniversity Institute for Research on the Earth System in Andalucia through the University of Granada; (3) Jos´e Camacho, Computational Data Science (CoDaS) Lab in the Department of Signal Theory, Telematics, and Communications at the University of Granada; (4) Regino Zamora, part of the Interuniversity Institute for Research on the Earth System in Andalucia through the University of Granada. Table of Links Abstract & Introduction Optimization of the Optical Interpolation Materials and Methods Results and Discussion Conclusion Appendix A: Proof of Hermitian Self-Adjoint product identity for Equidistant Time-Domain Measurements Appendix B: AAH ̸= MIN I in the Non-Equidistant Case Acknowledgments & References 3 MATERIALS AND METHODS 3.0.1 Remote Sensor Data Soil temperature data were collected in the Sierra Nevada National Park in Andaluc´ıa, Spain, as part of the Smart EcoMountains program through the Lifewatch ERIC Program, from solar-powered remote multi-parametric micro-stations located within different environments (shrub, rock, and bare-earth) and altitudes (from 1500m to 2300m) from 29- 07-2020 until 04-05-2023. Measurements were continuously collected at a nominal 10 minute interval with micro-sensors (ibuttons, thermochron-type; Maxim integrated) connected to a network that transmits the collected information when connectivity is available. All the collected data were visually inspected for extreme values outside the normal ranges of the variable in the time series due to sensor failures, identifying a single sensor reporting erroneous values that were reported as NaNs. 3.0.2 Computational information All calculations were run with a B550 AORUS ELITE AX V2 motherboard with 128 GiB DDR4 RAM, an AMD Ryzen 9 5950x 32 core processor with an NVIDIA GeForce RTX 3080 graphics processor, and a 2 TB NVMe Samsung SSD 980. Software was installed on Ubuntu 22.04.3 LTS 64-bit operating system “Jammy Jellyfish”. Graphical inspections and data cleaning were conducted with the tidyverse 2.0.0 package [13] implemented in the R 4.3.1 software environment [14]. Calculations were performed using Python 3.10. Data was parsed and cleaned from the original .csv values using Pandas 2.0.3. Various numerical operations were performed using the vectorized functions available in NumPy 1.25 [15], with additional statistical functionality from SciPy 1.11 [16]. Graphics were created using Matplotlib 3.7.1 [17]. This paper is under CC 4.0 license. available on arxiv

Remote Sensor Data Collection: Insights from Sierra Nevada National Park

Let’s explore the Unit of Work Pattern in C# for Clean Architecture! Clean Architecture is a popular paradigm in software engineering, and understanding the Unit of Work Pattern is a helpful pattern we can leverage when developing tidy, maintainable, and understandable code. We can put these two concepts together to help us build solid applications. The Unit of Work Pattern is a that provides an efficient way of handling database transactions. It is a part of the n-tier architecture that separates the business logic from the data access logic. This pattern helps developers focus on the code’s functionality, abstract the database layer, and improve the overall code quality. design pattern Clean Architecture is designed to achieve maintainable, flexible, and testable code that can be easily changed or adapted, making the code more resilient to change. It fosters the separation of concerns within a software project, which improves the code quality, performance, and maintainability. In the following sections, I will explain the Unit of Work Pattern, Clean Architecture, and how they work together. We’ll see some practical tips and code examples that will help you enhance your skills and knowledge of both of these topics! Understanding the Unit of Work Pattern in C# The Unit of Work pattern is a design pattern used in software engineering to manage database transactions. It is responsible for coordinating multiple repositories to ensure consistency and atomicity of database transactions. The Unit of Work pattern provides several benefits, including improved performance, reduced coupling between repositories and the database, and easier testability. To implement the Unit of Work pattern in C#, follow these steps: Define an interface for the Unit of Work class that implements a variety of methods, such as and . Commit() Rollback() Create a concrete implementation of the Unit of Work interface that manages the lifetime of the database context object. Define an interface for the repository class that implements methods like . Add(), Update(), and Delete() Create a concrete implementation of the repository interface that utilizes the Unit of Work for transaction management. Below is an example of how to implement the Unit of Work pattern in C#: public interface IUnitOfWork
{
    void Commit();
    void Rollback();
}

public class UnitOfWork : IUnitOfWork
{
    private readonly IDbContext _dbContext;

    public UnitOfWork(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void Commit()
    {
        _dbContext.SaveChanges();
    }

    public void Rollback()
    {
        // Rollback logic here
    }
}

public interface IRepository<T>
{
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

public class Repository<T> : IRepository<T> where T : class
{
    private readonly DbSet<T> _dbSet;

    public Repository(IDbContext dbContext)
    {
        _dbSet = dbContext.Set<T>();
    }

    public void Add(T entity)
    {
        _dbSet.Add(entity);
    }

    public void Update(T entity)
    {
        _dbSet.Attach(entity);
    }

    public void Delete(T entity)
    {
        _dbSet.Remove(entity);
    }
} By implementing the Unit of Work pattern in C#, you can easily manage database transactions using a single interface, reduce coupling between repositories and the database, and simplify testing of your data access layer. Clean Architecture in C# Clean approach that prioritizes the separation of concerns and the independence of frameworks and tools. This approach is centered around the idea of creating software systems that are easy to read, maintain, and test. architecture is a software design One of the core benefits of Clean Architecture is that it promotes an organized, maintainable, and scalable software structure that is easy to maintain over the lifetime of a project. Another benefit is that it promotes a focus on business logic over infrastructure and implementation details, which allows developers to design and build software systems that are more adaptable to change. When used in conjunction with the Unit of Work Pattern, Clean Architecture can become even more powerful, as it provides a clear separation of concerns between business logic and data access. By abstracting away the database implementation details into the Unit of Work Pattern, applications can become more flexible and easier to test. Some of the key benefits of using Clean Architecture are: Increased flexibility Easier testing Improved maintainability Separation of concerns Reduced coupling To see the benefits of Clean Architecture in action, consider the following code example: // this is an example of a (potentially) poorly organized, tightly-coupled code structure
// - directly accessing the DB context to fetch
// - directly accessing the DB context to write
public class MyClass
{
    private readonly IDbContext _dbContext;

    public MyClass(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void DoSomething(int id)
    {
        var entity = _dbContext.Set<Entity>().FirstOrDefault(e => e.Id == id);

        // ...

        _dbContext.SaveChanges();
    }
}

// this is an example of a clean code structure using Clean Architecture
// - using a repository interface to read
// - using a unit of work pattern to write
public class MyClass
{
    private readonly IRepository<Entity> _entityRepository;
    private readonly IUnitOfWork _unitOfWork;

    public MyClass(IRepository<Entity> entityRepository, IUnitOfWork unitOfWork)
    {
        _entityRepository = entityRepository;
        _unitOfWork = unitOfWork;
    }

    public void DoSomething(int id)
    {
        var entity = _entityRepository.GetById(id);

        // ...

        _unitOfWork.Commit();
    }
} By adopting Clean Architecture in conjunction with the Unit of Work Pattern, developers can create more scalable, maintainable, and testable software systems that are easier to work with over the lifetime of a project. By focusing on independent modules with well-defined interfaces, developers can achieve increased flexibility and reduced coupling, which leads to systems that are easier to evolve and extend over time. Implementing the Unit of Work Pattern in Clean Architecture To implement the Unit of Work pattern in Clean Architecture, use the following steps: Define an interface for the Unit of Work class that includes methods to manage database transactions, such as and . Commit() Rollback() Create a concrete implementation of the Unit of Work interface that manages the lifetime of the database context object. This should be done in the outer-most layer of the application, which may be a database access layer or a service layer. Define an interface for each repository class that includes methods like . These methods should use the Unit of Work to manage database transactions. Add(), Update(), and Delete() Create concrete implementations of each repository interface using a specific database implementation (like Entity Framework). Code Example of the Unit of Work Pattern in Clean Architecture Here is an example code structure for implementing the Unit of Work Pattern in Clean Architecture: // Application Layer
public interface IUnitOfWork
{
    void Commit();
    void Rollback();
}

public class UnitOfWork : IUnitOfWork
{
    private readonly IDbContext _dbContext;

    public UnitOfWork(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void Commit()
    {
        _dbContext.SaveChanges();
    }

    public void Rollback()
    {
        // Rollback logic here
    }
}

// Domain Layer
public interface IEntityRepository<T>
{
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

public class EntityRepository<T> : IRepository<T> where T : class
{
    private readonly DbSet<T> _dbSet;

    public EntityRepository(IDbContext dbContext)
    {
        _dbSet = dbContext.Set<T>();
    }

    public void Add(T entity)
    {
        _dbSet.Add(entity);
    }

    public void Update(T entity)
    {
        _dbSet.Attach(entity);
    }

    public void Delete(T entity)
    {
        _dbSet.Remove(entity);
    }
}

// Infrastructure Layer (Entity Framework-specific implementation)
public class EntityFrameworkDbContext : IDbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("your-connection-string-here");
    }

    public DbSet<Entity> Entities { get; set; }
}

public class EntityFrameworkUnitOfWork : IUnitOfWork
{
    private readonly EntityFrameworkDbContext _dbContext;

    public EntityFrameworkUnitOfWork(EntityFrameworkDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void Commit()
    {
        _dbContext.SaveChanges();
    }

    public void Rollback()
    {
        // Rollback logic here
    }
}

public class EntityFrameworkEntityRepository<T> : IEntityRepository<T> where T : class
{
    private readonly EntityFrameworkDbContext _dbContext;
    private readonly DbSet<T> _dbSet;

    public EntityFrameworkEntityRepository(EntityFrameworkDbContext dbContext)
    {
        _dbContext = dbContext;
        _dbSet = dbContext.Set<T>();
    }

    public void Add(T entity)
    {
        _dbSet.Add(entity);
    }

    public void Update(T entity)
    {
        _dbSet.Attach(entity);
    }

    public void Delete(T entity)
    {
        _dbSet.Remove(entity);
    }
} Benefits of Implementing the Unit of Work Pattern in Clean Architecture Implementing the Unit of Work pattern in Clean Architecture provides many benefits, including improved code maintainability, scalability, and testability. The following are the key benefits of this approach: By abstracting away the lower-level database code into the Unit of Work pattern, this implementation reduces coupling between the repository layer and the database. This makes it easier to switch out database implementations or make database schema changes without affecting higher-level business logic in the application’s layers. Reduced Coupling: The Unit of Work pattern makes it easier to maintain the application codebase since developers don’t need to worry about managing multiple database connections or transactions. This makes the code cleaner and easier to understand. Additionally, using the Clean Architecture approach means that different layers of the application are organized according to their concerns, which further improves maintainability. Improved Maintainability: With the Unit of Work pattern and Clean Architecture approach, developers can more easily test the application. They can create mock objects for the repository classes and Unit of Work and test business logic without creating integration tests with a database. This makes testing faster, less brittle, and saves valuable development time. Simplified Testing: By implementing the Unit of Work pattern in Clean Architecture, developers can build applications that are flexible, maintainable, and scalable. The separation of concerns enabled by the clean architecture approach makes it easier to maintain or change code over time with minimal impact on other application layers. Finally, this approach provides developers with a simplified testing process that helps them write better code faster. Common Mistakes & Suggestions for the Unit of Work Pattern Despite the many benefits of the Unit of Work pattern in C#, there are several common mistakes that developers make when implementing this design pattern. Some of these mistakes can lead to bugs, poor performance, or other issues that affect the overall quality of the software. Common Mistakes When Implementing the Unit of Work Pattern The following are some common mistakes made when implementing the Unit of Work pattern: : The Unit of Work pattern is intended to simplify data access by providing a single interface for database transactions. However, some developers overcomplicate this interface by including unnecessary methods or business logic. This results in bloated and difficult-to-understand code. Overcomplicating the Unit of Work : One of the main benefits of the Unit of Work pattern is the ability to manage transactions using the Commit() and Rollback() methods. However, some developers fail to manage these transactions properly, which can result in partial updates or corrupted data. Not properly managing transactions : If the Unit of Work pattern is not properly abstracted from the database layer, developers may end up with tight coupling between their application and the database. This can make it difficult to make changes to the database schema or switch to a new database technology and may result in poor performance. Failing to properly abstract the database layer Suggestions When Implementing the Unit of Work Pattern To avoid these common mistakes, it’s important to follow best practices when implementing the Unit of Work pattern. Some tips for avoiding these mistakes include: : The Unit of Work interface should only include the methods necessary to manage transactions. Additional business logic should be kept in the repository layer or other parts of the application. Keeping the Unit of Work simple : Developers should ensure that transactions are properly managed using the and methods. If possible, developers should use a transaction scope to ensure that transactions are atomic and consistent. Implementing the Unit of Work correctly Commit() Rollback() : The Unit of Work pattern should be properly abstracted from the database layer to allow for flexibility and maintainability. This can be accomplished by using an ORM-like Entity Framework that provides a layer of abstraction between the application and the database. Abstracting the database layer By following these tips and avoiding common mistakes, developers can implement the Unit of Work pattern in a way that maximizes its benefits and improves the overall quality of their software. Wrapping Up the Unit of Work Pattern in C# for Clean Architecture The Unit of Work Pattern in C# for Clean Architecture can be very helpful for software engineers to follow. It allows for better separation of concerns, simpler code maintenance, improved testability, and easier scalability. By utilizing Clean Architecture with the Unit of Work pattern, you can take full advantage of the many benefits that both of these offer. By using the tips and techniques outlined in this article, you can take your software engineering skills to the next level and create more robust and scalable applications. Fall back to the code examples to see how the pattern can work in its basic form, and see if it makes sense for you while implementing clean architecture. Try with Clean Architecture in your project! Doing so can contribute to more efficient development processes and more successful software outcomes. implementing the Unit of Work pattern Also published here.

Stories, News & Mentions about TYDY

Tydy’s Stories on HackerNoon