Born in an agency that interfaced with hundreds of companies, \"Assigned\" solves the problem of delegating to external teams

Assigned

assigned

To push-back or just suck it up? “I wish you had told me you hated the project this bad” My manager remarked when I told him I was leaving for another team. I really liked my manager, I was proud of working in the team but among other reasons, continuing to work in technical-debt fixing for more than a year while most members of my team were busy launching a promising v1 project, was affecting my happiness. I voiced my concerns but having done it for so long, I knew the area better than others. After a year of seeing opportunities pass by, I decided to make the move thus leading my team to lose a productive employee and myself leaving a team which I felt proud by association. My story is an example of “sucking-it-up”. Regardless when I saw the , most answers seemed to suggest that is the only way. The top answer suggested: question on Quora when you are assigned a job that you are not interested in doing, and which you know is still work that needs to be done… …you do that work to the best of your ability, despite your disinterest. You are at a job. Part of that job is — in exchange for money — you give them your time, and they spend your time how they see fit. He has a valid point. However this leads to perpetuation of hierarchy-driven mindset, where being below in the chain of command you shut up and do whatever asked because you’re being paid. Apart from creating a toxic work culture, this viewpoint overlooks your life might comprise more than just this job, and everything you do in your current job gives you valuable skills for a role. After all, it’s you and only you who are the best career advocate for yourself and if you don’t look after your interests, no one else will. future When I was allocated the project, I had enthusiastically accepted it. I liked my manager, wanted to impress him, fellow team members in the project were awesome. 6 months went by, the project dragged on, scope-creep happened. I was meddling into the deepest layers of legacy code while other v1 projects had started. After voicing my discontent to my manager, he made sure I was taken out. Unfortunately I was one of the few people who knew the area well so they needed to put me back to expedite the project. And there seemed to be no end in the near-term. I was unhappy, but understood his perspective. No light at the end of the tunnel The Management Perspective In companies- particularly big ones- there is a lot of thankless, grunt work waiting for some new poor schmuck who doesn’t protest too much to take it up. Some typical examples are tools, build systems, automation which always fails thus failing to catch actual regressions and of course porting code. From the company’s perspective, this is all important work which is increasing the debt and longer left, the harder it gets to fix. It’s understandable that needs to do it. So when after management discussions they choose schmucks and you straight out say no, your manager is in a tough spot. It’s in their best interest to get you accept this to avoid immediate friction, and cycling back to rest of management. technology someone for the time being So back to the original question: how should you react when you’re allotted a project which you think is not adding to your skills but as a junior software engineer don’t want to ruffle feathers? The two main goals of a job are: To make your manager look good. Optimize for skill development, and look out for your interests So even though answer depends on factors such as timing, tenure, personalities my general advice would be a . Accept the allotment, but let the manager know you don’t want to get stuck in it for too long and let them know your areas of interest. This allows them to save face with the rest of management team and buys them time to ask for alternative resources down the line, while making your goals clear and asserting yourself as someone willing to do unpleasant work in times of need. Based on how good the manager is, and your relationship with them it is their responsibility to match your interests to your work without compromising company’s interests. While communicating this, the things to consider are timing and delivery. Don’t bring it up when your manager is in a bad mood, or this particular project has been source of immediate stress for them. It might also be worth waiting to develop a reputation if you’re super new in the team (< 6 months). However you’re never too new to communicate your interest areas to your manager. Finally speak in a way without seeming like a rabble rouser. “yes, but…” If your manager reacts like Michael Scott, do yourself a favor and leave There is always a but … However if you’re in a situation where your manager is not cooperative, gets angry, dismisses your concern or there is no project in the team which excites you the only solution might be to vote with your feet. In tech there are lots of other jobs and it’s not worth suffering through terrible projects for years because some people with authoritarian mindsets believe the person at the bottom of the chain should put up with crap. It’s true there are thankless projects everywhere and at some point in your life you’ve to work in them and if the mere thought of working in an uninteresting project makes you switch, then you’d be switching careers every few months eventually becoming unemployable. However if you’re finding yourself in the middle of a never-ending swamp, the end not being in sight and find essential skills and opportunities slipping away despite voicing your concerns, it might mean making the hard decision to change. I write more similar content in the technology section of my blog- The Travelling Engineer . Do follow the blog.

What to do when assigned uninteresting software engineering projects?

Tailoring Textual Resources for Evaluation Tasks: Long-Form Text Summarization

Violence Detection in Videos: Experiments and Results

ভিডিওতে সহিংসতা সনাক্তকরণ: পরীক্ষা এবং ফলাফল

Gewalterkennung in Videos: Experimente und Ergebnisse

Detección de violencia en videos: experimentos y resultados

Détection de la violence dans les vidéos : expériences et résultats

वीडियो में हिंसा का पता लगाना: प्रयोग और परिणाम

動画における暴力検出: 実験と結果

동영상의 폭력 감지: 실험 및 결과

Detecção de violência em vídeos: experimentos e resultados

Обнаружение насилия в видео: эксперименты и результаты

Videolarda Şiddet Tespiti: Deneyler ve Sonuçlar

Phát hiện bạo lực trong video: Thử nghiệm và kết quả

视频中的暴力检测：实验和结果

Violence Detection in Videos: Proposed Approach

ভিডিওতে সহিংসতা সনাক্তকরণ: প্রস্তাবিত পদ্ধতি

Gewalterkennung in Videos: Vorgeschlagener Ansatz

Detección de violencia en videos: enfoque propuesto

Détection de la violence dans les vidéos : approche proposée

वीडियो में हिंसा का पता लगाना: प्रस्तावित दृष्टिकोण

動画内の暴力検出: 提案されたアプローチ

비디오의 폭력 감지: 제안된 접근 방식

Detecção de violência em vídeos: abordagem proposta

Обнаружение насилия в видео: предлагаемый подход

Videolarda Şiddet Tespiti: Önerilen Yaklaşım

Phát hiện bạo lực trong video: Phương pháp đề xuất

视频中的暴力检测：建议的方法

How Non-PII Data Can Deanonymize Users

Authors:
(1) Ángel Merino, Department of Telematic Engineering Universidad Carlos III de Madrid {angel.merino@uc3m.es};
(2) José González-Cabañas, UC3M-Santander Big Data Institute {jose.gonzalez.cabanas@uc3m.es}
(3) Ángel Cuevas, Department of Telematic Engineering Universidad Carlos III de Madrid & UC3M-Santander Big Data Institute {acrumin@it.uc3m.es};
(4) Rubén Cuevas, Department of Telematic Engineering Universidad Carlos III de Madrid & UC3M-Santander Big Data Institute {rcuevas@it.uc3m.es}. Table of Links Abstract and Introduction LinkedIn Advertising Platform Background Dataset Methodology User’s Uniqueness on LinkedIn Nanotargeting proof of concept Discussion Related work Ethics and legal considerations Conclusions, Acknowledgments, and References Appendix 3 Dataset This work assesses if combining location and professional skills makes a user unique on LinkedIn. To do that, we created a dataset including thousands of audience sizes for different combinations of locations and skills from real LinkedIn profiles. We had to implement two different pieces of software to obtain that dataset. The first one retrieved the location and professional skills from hundreds of LinkedIn users. The second used the information from those profiles to retrieve the audience size from the LinkedIn Campaign Manager for thousands of audiences combining location and professional skills. 3.1 Users’ Skills and Location Our goal was to create a user base with random profiles. To that end, we used the Campaign Manager’s job type classification. This field is known as job functions and includes a general list of 26 professional fields. We launched a search query on DuckDuckGo for each of the 26 job functions, using a filter to only obtain LinkedIn profiles, and retrieved the first ten results for each category. This led to 260 seed users from whom we collected the skills and locations they reported in their profiles. Starting with those users, we conducted a Breadth-First Search (BFS) [12] and gathered information from the users LinkedIn suggested when accessing the seed profiles. Overall, we collected skills and location information from 1699 LinkedIn users. We did not collect unique IDs from LinkedIn user profiles and instead used a pseudonymization process that assigned a random identifier to each user in our database. We aimed to avoid directly linking our collected data to the LinkedIn profiles from which we retrieved the information. Our dataset included 4941 unique skills that appeared 39095 times across the 1699 user profiles. This means that each unique skill was reported by 8 users in our dataset on average. All the users in our data sample reported at least one skill, and 1690 (99.47%) also provided a location (country, region, or city). Appendix A shows the distribution of the users across countries, derived from the location reported by each user. Figure 1 shows the CDF of the number of skills reported per user. The distribution’s median value is 20 skills. This implies that half of the individuals in our data sample have written at least 20 skills in their profile. We note the maximum number of skills users can report on LinkedIn is 50. 3.2 Audience Size We implemented ad hoc software to systematically obtain the size of LinkedIn audiences based on the skills and location of the 1699 individuals in our dataset. This data feeds the methodology outlined in the next section, which computes how many skills are necessary to make a user unique on LinkedIn. Figure 2 shows the CDF of the worldwide audience size associated with the 4941 professional skills in our final dataset. A LinkedIn skill is featured in 780k profiles on average. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: (1) Ángel Merino, Department of Telematic Engineering Universidad Carlos III de Madrid {angel.merino@uc3m.es}; (2) José González-Cabañas, UC3M-Santander Big Data Institute {jose.gonzalez.cabanas@uc3m.es} (3) Ángel Cuevas, Department of Telematic Engineering Universidad Carlos III de Madrid & UC3M-Santander Big Data Institute {acrumin@it.uc3m.es}; (4) Rubén Cuevas, Department of Telematic Engineering Universidad Carlos III de Madrid & UC3M-Santander Big Data Institute {rcuevas@it.uc3m.es}. Authors: Authors: (1) Ángel Merino, Department of Telematic Engineering Universidad Carlos III de Madrid {angel.merino@uc3m.es}; (2) José González-Cabañas, UC3M-Santander Big Data Institute {jose.gonzalez.cabanas@uc3m.es} (3) Ángel Cuevas, Department of Telematic Engineering Universidad Carlos III de Madrid & UC3M-Santander Big Data Institute {acrumin@it.uc3m.es}; (4) Rubén Cuevas, Department of Telematic Engineering Universidad Carlos III de Madrid & UC3M-Santander Big Data Institute {rcuevas@it.uc3m.es}. Table of Links Abstract and Introduction Abstract and Introduction LinkedIn Advertising Platform Background LinkedIn Advertising Platform Background Dataset Dataset Methodology Methodology User’s Uniqueness on LinkedIn User’s Uniqueness on LinkedIn Nanotargeting proof of concept Nanotargeting proof of concept Discussion Discussion Related work Related work Ethics and legal considerations Ethics and legal considerations Conclusions, Acknowledgments, and References Conclusions, Acknowledgments, and References Appendix Appendix 3 Dataset This work assesses if combining location and professional skills makes a user unique on LinkedIn. To do that, we created a dataset including thousands of audience sizes for different combinations of locations and skills from real LinkedIn profiles. We had to implement two different pieces of software to obtain that dataset. The first one retrieved the location and professional skills from hundreds of LinkedIn users. The second used the information from those profiles to retrieve the audience size from the LinkedIn Campaign Manager for thousands of audiences combining location and professional skills. 3.1 Users’ Skills and Location Our goal was to create a user base with random profiles. To that end, we used the Campaign Manager’s job type classification. This field is known as job functions and includes a general list of 26 professional fields. We launched a search query on DuckDuckGo for each of the 26 job functions, using a filter to only obtain LinkedIn profiles, and retrieved the first ten results for each category. This led to 260 seed users from whom we collected the skills and locations they reported in their profiles. Starting with those users, we conducted a Breadth-First Search (BFS) [12] and gathered information from the users LinkedIn suggested when accessing the seed profiles. Overall, we collected skills and location information from 1699 LinkedIn users. We did not collect unique IDs from LinkedIn user profiles and instead used a pseudonymization process that assigned a random identifier to each user in our database. We aimed to avoid directly linking our collected data to the LinkedIn profiles from which we retrieved the information. Our dataset included 4941 unique skills that appeared 39095 times across the 1699 user profiles. This means that each unique skill was reported by 8 users in our dataset on average. All the users in our data sample reported at least one skill, and 1690 (99.47%) also provided a location (country, region, or city). Appendix A shows the distribution of the users across countries, derived from the location reported by each user. Figure 1 shows the CDF of the number of skills reported per user. The distribution’s median value is 20 skills. This implies that half of the individuals in our data sample have written at least 20 skills in their profile. We note the maximum number of skills users can report on LinkedIn is 50. 3.2 Audience Size We implemented ad hoc software to systematically obtain the size of LinkedIn audiences based on the skills and location of the 1699 individuals in our dataset. This data feeds the methodology outlined in the next section, which computes how many skills are necessary to make a user unique on LinkedIn. Figure 2 shows the CDF of the worldwide audience size associated with the 4941 professional skills in our final dataset. A LinkedIn skill is featured in 780k profiles on average. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. available on arxiv

Creating a Dataset for LinkedIn User Analysis

Bitcoin UTXO’s Model, Powering A Unique Ecosystem

Authors:
(1) Vahid Majdinasab, Department of Computer and Software Engineering Polytechnique Montreal, Canada;
(2) Michael Joshua Bishop, School of Mathematical and Computational Sciences Massey University, New Zealand;
(3) Shawn Rasheed, Information & Communication Technology Group UCOL - Te Pukenga, New Zealand;
(4) Arghavan Moradidakhel, Department of Computer and Software Engineering Polytechnique Montreal, Canada;
(5) Amjed Tahir, School of Mathematical and Computational Sciences Massey University, New Zealand;
(6) Foutse Khomh, Department of Computer and Software Engineering Polytechnique Montreal, Canada. Table of Links Abstract and Introduction Original Study Replication Scope and Methodology Results Discussion Related Work Conclusion, Acknowledgments, and References III. REPLICATION SCOPE AND METHODOLOGY Table I provides an overview of the experimental setups followed in the original study and in this replication. Details of our methodology for generating the CWE scenarios and our manual analysis are provided below. A. Generating CWE scenarios using Copilot In this study, we focus our experimental analysis on the Python language and analyzed scenarios related to twelve CWEs (details are shown in Table II). For each CWE, we adapted the scenarios from the original study of Pearce et al. [14]. The original study employed three distinct sources to develop these scenarios. The initial source includes CodeQL examples and documentation. The second source encompasses examples provided for each CWE in MITRE’s dataset. The final source involves scenarios designed by the author. Copilot is prompted to complete each scenario by placing the cursor at the position where code completion is needed. It is important to note that these scenarios do not contain vulnerabilities; our objective is to examine whether the code added by Copilot to complete the scenarios introduces any vulnerabilities. Our objective was to gather 25 solutions proposed by Copilot for each scenario. Although Copilot’s configuration in Visual Studio Code IDE [3] provides various settings, such as the option to define the maximum number of displayed solutions (ListCount), in the version (1.77.9225) utilized for this study, this parameter does not function as intended. Regardless of our attempts to set the maximum solutions anywhere from 10 to 100, the tool consistently returns a random quantity of solutions in each iteration. To address this limitation, we collect up to 55 solutions generated by Copilot for each scenario across multiple iterations. Given that this study aims to investigate potential vulnerabilities in Copilot’s suggestions, our evaluation concentrates solely on identifying vulnerabilities within the provided suggestions rather than assessing their accuracy in addressing the prompts. However, it is important to note that some of the suggestions proposed by Copilot exhibit syntax errors. We excluded such suggestions from our evaluation process for two reasons. First, in order to scan them for security weaknesses using CodeQL, the code must be compilable. Moreover, in line with the original study [14] and the work of Dakhel et al. [5], there are potential instances of duplication in Copilot’s top-n suggestions. To address this issue, we adopted the same strategy as recommended in [5] to eliminate duplicates. This approach involves computing the similarity between the Abstract Syntax Trees (ASTs) of different suggestions, with an exclusion of the leaves corresponding to variable or function names (including all natural language content). In order to compare the ASTs of solutions, the codes must not contain any syntax errors and therefore we exclude those that cannot be compiled. For removing the duplicate solutions, in cases where the similarity between two ASTs is identified as 1, we categorize them as duplicates and subsequently eliminate one of them. It is noteworthy that, in the original study [14], duplicates were removed by comparing the sequences of tokens, which resulted in the identification of distinct duplicate code snippets in their collected solutions, differing only in variable or function names or content of comments in different lines of codes. Using AST similarity to remove the duplicates between the suggested solutions allows us to have a more accurate understanding of Copilot’s faults. B. Static Analysis with CodeQL CodeQL analysis was conducted on a machine with an Intel Xeon E5-2690 v3 processor with a memory of 128GB DDR4 RAM running Ubuntu 20.04.5 LTS. The analysis took 16 minutes 37 seconds real-time. Automated Python scripts were used to run the database build and analysis tests based on parameters specific to each sample set/CWE. All scenarios and scripts used during our analysis were developed for Python 3.8.10. CodeQL version 2.12.4 of the command line toolchain was used for static security analysis. An example of CodeQL’s output for a vulnerability is shown in Fig. 1. C. Manual Analysis We conducted a manual analysis for the code suggestions that we could not analyze using CodeQL. We analyzed a total of 141 code samples related to four CWEs (i.e., CWE-434, CWE-306, CWE-200 and CWE-522). This manual analysis was conducted by two coders (both are coauthors). Both coders have experience with security analysis and have discussed the vulnerabilities and the review protocol before conducting the analysis. Each coder was assigned a set of code suggestions to validate whether they contained the specific CWE under investigation. The two coders first analyzed 12 code suggestions (3 suggestions for each of the four CWEs) to verify their classification and agree on the classification approach. Once both agreed on the classification, the coders thoroughly checked the assigned code suggestions individually. Once the individual tasks were completed, the coders cross-validated their classification by verifying five randomly selected suggestions for each CWE, totaling 20 suggestions. Of those 20 suggestions, both have agreed on 18 suggestions (reaching 90% agreement rate). The remaining two suggestions were resolved via discussion. We note that, for all code suggestions we analyzed, we focused only on the CWE under investigation, and we did not consider other potential security vulnerabilities that may impact the code. For example, when analyzing CWE-522 code suggestions, we did not consider the strength of the hashing algorithm implemented as we deemed it irrelevant to our analysis. D. Limitations As we are unable to determine the version of Copilot used in the original study, it is not possible for us to reproduce the same results (using the version of Copilot) as the original study. We have had challenges related to Copilot API changes. We noted that the API changes to Copilot (in the latest versions) have made analyzing the generated code (through CodeQL static analysis) more difficult. Similarly, Copilot frequently generates non-runnable code, not allowing us to automatically run CodeQL on some code. Therefore, we ended up removing such code suggestions from our analysis. Some CWEs in the original study, namely CWE-22 (TarSlip scenario) and CWE-798, were analyzed with custom CodeQL queries and these queries are no longer compatible with the version of CodeQL used in our study. Compatible queries that cover the same CWE’s were run on these scenarios. E. Replication Package We provide our full dataset, including all generated CWEs code scenarios, CodeQL databases, and other scripts in our repository at https://github.com/CommissarSilver/CVT. This paper is available on arxiv under CC 4.0 license. [3] https://code.visualstudio.com Authors: (1) Vahid Majdinasab, Department of Computer and Software Engineering Polytechnique Montreal, Canada; (2) Michael Joshua Bishop, School of Mathematical and Computational Sciences Massey University, New Zealand; (3) Shawn Rasheed, Information & Communication Technology Group UCOL - Te Pukenga, New Zealand; (4) Arghavan Moradidakhel, Department of Computer and Software Engineering Polytechnique Montreal, Canada; (5) Amjed Tahir, School of Mathematical and Computational Sciences Massey University, New Zealand; (6) Foutse Khomh, Department of Computer and Software Engineering Polytechnique Montreal, Canada. Authors: Authors: (1) Vahid Majdinasab, Department of Computer and Software Engineering Polytechnique Montreal, Canada; (2) Michael Joshua Bishop, School of Mathematical and Computational Sciences Massey University, New Zealand; (3) Shawn Rasheed, Information & Communication Technology Group UCOL - Te Pukenga, New Zealand; (4) Arghavan Moradidakhel, Department of Computer and Software Engineering Polytechnique Montreal, Canada; (5) Amjed Tahir, School of Mathematical and Computational Sciences Massey University, New Zealand; (6) Foutse Khomh, Department of Computer and Software Engineering Polytechnique Montreal, Canada. Table of Links Abstract and Introduction Abstract and Introduction Original Study Original Study Replication Scope and Methodology Replication Scope and Methodology Results Results Discussion Discussion Related Work Related Work Conclusion, Acknowledgments, and References Conclusion, Acknowledgments, and References III. REPLICATION SCOPE AND METHODOLOGY Table I provides an overview of the experimental setups followed in the original study and in this replication. Details of our methodology for generating the CWE scenarios and our manual analysis are provided below. A. Generating CWE scenarios using Copilot A. Generating CWE scenarios using Copilot In this study, we focus our experimental analysis on the Python language and analyzed scenarios related to twelve CWEs (details are shown in Table II). For each CWE, we adapted the scenarios from the original study of Pearce et al. [14]. The original study employed three distinct sources to develop these scenarios. The initial source includes CodeQL examples and documentation. The second source encompasses examples provided for each CWE in MITRE’s dataset. The final source involves scenarios designed by the author. Copilot is prompted to complete each scenario by placing the cursor at the position where code completion is needed. It is important to note that these scenarios do not contain vulnerabilities; our objective is to examine whether the code added by Copilot to complete the scenarios introduces any vulnerabilities. Our objective was to gather 25 solutions proposed by Copilot for each scenario. Although Copilot’s configuration in Visual Studio Code IDE [3] provides various settings, such as the option to define the maximum number of displayed solutions (ListCount), in the version (1.77.9225) utilized for this study, this parameter does not function as intended. Regardless of our attempts to set the maximum solutions anywhere from 10 to 100, the tool consistently returns a random quantity of solutions in each iteration. To address this limitation, we collect up to 55 solutions generated by Copilot for each scenario across multiple iterations. Given that this study aims to investigate potential vulnerabilities in Copilot’s suggestions, our evaluation concentrates solely on identifying vulnerabilities within the provided suggestions rather than assessing their accuracy in addressing the prompts. However, it is important to note that some of the suggestions proposed by Copilot exhibit syntax errors. We excluded such suggestions from our evaluation process for two reasons. First, in order to scan them for security weaknesses using CodeQL, the code must be compilable. Moreover, in line with the original study [14] and the work of Dakhel et al. [5], there are potential instances of duplication in Copilot’s top-n suggestions. To address this issue, we adopted the same strategy as recommended in [5] to eliminate duplicates. This approach involves computing the similarity between the Abstract Syntax Trees (ASTs) of different suggestions, with an exclusion of the leaves corresponding to variable or function names (including all natural language content). In order to compare the ASTs of solutions, the codes must not contain any syntax errors and therefore we exclude those that cannot be compiled. For removing the duplicate solutions, in cases where the similarity between two ASTs is identified as 1, we categorize them as duplicates and subsequently eliminate one of them. It is noteworthy that, in the original study [14], duplicates were removed by comparing the sequences of tokens, which resulted in the identification of distinct duplicate code snippets in their collected solutions, differing only in variable or function names or content of comments in different lines of codes. Using AST similarity to remove the duplicates between the suggested solutions allows us to have a more accurate understanding of Copilot’s faults. B. Static Analysis with CodeQL B. Static Analysis with CodeQL CodeQL analysis was conducted on a machine with an Intel Xeon E5-2690 v3 processor with a memory of 128GB DDR4 RAM running Ubuntu 20.04.5 LTS. The analysis took 16 minutes 37 seconds real-time. Automated Python scripts were used to run the database build and analysis tests based on parameters specific to each sample set/CWE. All scenarios and scripts used during our analysis were developed for Python 3.8.10. CodeQL version 2.12.4 of the command line toolchain was used for static security analysis. An example of CodeQL’s output for a vulnerability is shown in Fig. 1. C. Manual Analysis C. Manual Analysis We conducted a manual analysis for the code suggestions that we could not analyze using CodeQL. We analyzed a total of 141 code samples related to four CWEs (i.e., CWE-434, CWE-306, CWE-200 and CWE-522). This manual analysis was conducted by two coders (both are coauthors). Both coders have experience with security analysis and have discussed the vulnerabilities and the review protocol before conducting the analysis. Each coder was assigned a set of code suggestions to validate whether they contained the specific CWE under investigation. The two coders first analyzed 12 code suggestions (3 suggestions for each of the four CWEs) to verify their classification and agree on the classification approach. Once both agreed on the classification, the coders thoroughly checked the assigned code suggestions individually. Once the individual tasks were completed, the coders cross-validated their classification by verifying five randomly selected suggestions for each CWE, totaling 20 suggestions. Of those 20 suggestions, both have agreed on 18 suggestions (reaching 90% agreement rate). The remaining two suggestions were resolved via discussion. We note that, for all code suggestions we analyzed, we focused only on the CWE under investigation, and we did not consider other potential security vulnerabilities that may impact the code. For example, when analyzing CWE-522 code suggestions, we did not consider the strength of the hashing algorithm implemented as we deemed it irrelevant to our analysis. D. Limitations D. Limitations As we are unable to determine the version of Copilot used in the original study, it is not possible for us to reproduce the same results (using the version of Copilot) as the original study. We have had challenges related to Copilot API changes. We noted that the API changes to Copilot (in the latest versions) have made analyzing the generated code (through CodeQL static analysis) more difficult. Similarly, Copilot frequently generates non-runnable code, not allowing us to automatically run CodeQL on some code. Therefore, we ended up removing such code suggestions from our analysis. Some CWEs in the original study, namely CWE-22 (TarSlip scenario) and CWE-798, were analyzed with custom CodeQL queries and these queries are no longer compatible with the version of CodeQL used in our study. Compatible queries that cover the same CWE’s were run on these scenarios. E. Replication Package E. Replication Package We provide our full dataset, including all generated CWEs code scenarios, CodeQL databases, and other scripts in our repository at https://github.com/CommissarSilver/CVT. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv [3] https://code.visualstudio.com

Uncovering Copilot's Weaknesses: Replication Methodology and Security Analysis

Workload Isolation in Apache Doris: Optimizing Resource Management and Performance

Apache Doris-এ কাজের চাপ বিচ্ছিন্নতা: সম্পদ ব্যবস্থাপনা এবং কর্মক্ষমতা অপ্টিমাইজ করা

Workload-Isolation in Apache Doris: Optimierung von Ressourcenmanagement und Leistung

Aislamiento de cargas de trabajo en Apache Doris: optimización de la gestión de recursos y el rendimiento

Isolation des charges de travail dans Apache Doris : optimisation de la gestion des ressources et des performances

अपाचे डोरिस में कार्यभार अलगाव: संसाधन प्रबंधन और प्रदर्शन का अनुकूलन

Apache Doris におけるワークロード分離: リソース管理とパフォーマンスの最適化

Apache Doris의 워크로드 격리: 리소스 관리 및 성능 최적화

Isolamento de carga de trabalho no Apache Doris: otimizando o gerenciamento e o desempenho de recursos

Изоляция рабочей нагрузки в Apache Doris: оптимизация управления ресурсами и производительности

Apache Doris'te İş Yükü Yalıtımı: Kaynak Yönetimini ve Performansı Optimize Etme

Cách ly khối lượng công việc trong Apache Doris: Tối ưu hóa hiệu suất và quản lý tài nguyên

Apache Doris 中的工作负载隔离：优化资源管理和性能

Physical Properties of KIC 9851944: Conclusion, Data Availability, Acknowledgments, and References

Despite their ubiquity in modern life, maps have a distinct set of challenges that set them apart from other visualizations, such as charts or tables. Even by the standard of the large datasets we often work with at The Markup, geospatial data is voluminous and complex, because the physical world it encapsulates is big and messy. A good map summarizes and simplifies the territory it represents, without distortion or destruction. As if such a task weren’t tough enough, any aspiring cartographer must also deal with the laws of geometry, which make it impossible to flatten the spherical Earth (technically an oblate ellipsoid) onto a two-dimensional plane without some compromises. At The Markup, we add a final hurdle to this obstacle course: our privacy promise. The Markup pledges to collect as little information as possible about our readers. We do not use tracking cookies on our site. We scrutinize third-party services before including them in our articles or elsewhere on our site. Many include trackers or analytics that would collect data on our readers. These may be standard across much of the web, but we don’t use them. As a result, when we decided to map the addresses we’d collected in our investigation into internet speeds across the U.S., we ran into a familiar problem. Investigative journalists Leon Yin and Aaron Sankin collected over a million internet offers in 45 U.S. cities and found a quartet of major ISPs routinely charged customers the same price for vastly different internet speeds (a practice called “tier flattening”). By analyzing the download speeds providers offered to these addresses with Census demographics and digitized historical maps, Leon and Aaron found ISPs disproportionately offered the worst deals to neighborhoods with the lowest concentration of White residents and lower median incomes. We wanted to plot our results on a map, so readers, activists and other journalists could pan across their city, zoom down to the street level, and see house-by-house internet speeds. Initially we turned to Mapbox, an established leader for generating and publishing online maps. But when we embedded a map from Mapbox on our staging website, we found it assigned a tracker that could not be disabled without violating Mapbox’s terms of service. This wasn’t the first time we’ve run into this problem with third-party services. Longtime Markup readers may remember how long it took us to find an email provider that allowed us to disable the trackers that would otherwise be sent out in our newsletters. We’ve also had to build our own privacy-protecting video player, donation platform, A/B testing tool, and more. We went looking for a tracker-free map, and considered our options. We use Datawrapper for many of our basic charts and maps, but Datawrapper only supports up to 100 points on a symbol map. We had to plot more than 900,000 addresses. We surveyed the vast landscape of mapping solutions, examining services such as Felt and Protomaps. Ultimately we settled on MapTiler, a Swiss company. MapTiler offered a flexible—and most importantly, tracker-free—suite of tools for hosting and styling map data. Their privacy policy clearly documents the information they collect and where, even specifying they only hold IP addresses of visitors in their memory for a short time before destroying them. And unlike some proprietary products, MapTiler sources its base map from OpenStreetMap, an open-source collection of geographic data. As part of the investigation, Leon collected addresses from two open-source datasets, OpenAddresses and NYC OpenData, both of which came with latitude and longitude coordinates assigned to each street address. We used the command line tool tippecanoe to transform these addresses into vector tiles, carving up address locations into smaller subsets which could be quickly loaded in the browser. Finally, we used MapLibre GL JS, an open-source derivative of Mapbox’s mapping library, to display the base map and address tiles on our website. We added features such as a tooltip with the details of every address, and filters to isolate neighborhoods by demographics. The end result, which was published on May 11, reveals the stark disparities in internet speeds in major urban areas across the country. We hope it will open up a new frontier of Markup maps. By Joel Eastwood Also published here Photo by Andrew Neel on Unsplash Despite their ubiquity in modern life, maps have a distinct set of challenges that set them apart from other visualizations, such as charts or tables. Even by the standard of the large datasets we often work with at The Markup, geospatial data is voluminous and complex, because the physical world it encapsulates is big and messy. A good map summarizes and simplifies the territory it represents, without distortion or destruction. As if such a task weren’t tough enough, any aspiring cartographer must also deal with the laws of geometry, which make it impossible to flatten the spherical Earth (technically an oblate ellipsoid) onto a two-dimensional plane without some compromises. At The Markup, we add a final hurdle to this obstacle course: our privacy promise . privacy promise The Markup pledges to collect as little information as possible about our readers. We do not use tracking cookies on our site. We scrutinize third-party services before including them in our articles or elsewhere on our site. Many include trackers or analytics that would collect data on our readers. These may be standard across much of the web, but we don’t use them. As a result, when we decided to map the addresses we’d collected in our investigation into internet speeds across the U.S. , we ran into a familiar problem. investigation into internet speeds across the U.S. Investigative journalists Leon Yin and Aaron Sankin collected over a million internet offers in 45 U.S. cities and found a quartet of major ISPs routinely charged customers the same price for vastly different internet speeds (a practice called “ tier flattening ”). tier flattening By analyzing the download speeds providers offered to these addresses with Census demographics and digitized historical maps , Leon and Aaron found ISPs disproportionately offered the worst deals to neighborhoods with the lowest concentration of White residents and lower median incomes. digitized historical maps We wanted to plot our results on a map, so readers, activists and other journalists could pan across their city, zoom down to the street level, and see house-by-house internet speeds. Initially we turned to Mapbox , an established leader for generating and publishing online maps. But when we embedded a map from Mapbox on our staging website, we found it assigned a tracker that could not be disabled without violating Mapbox’s terms of service . Mapbox terms of service This wasn’t the first time we’ve run into this problem with third-party services. Longtime Markup readers may remember how long it took us to find an email provider that allowed us to disable the trackers that would otherwise be sent out in our newsletters. We’ve also had to build our own privacy-protecting video player, donation platform, A/B testing tool, and more . find an email provider video player, donation platform, A/B testing tool, and more We went looking for a tracker-free map, and considered our options. We use Datawrapper for many of our basic charts and maps, but Datawrapper only supports up to 100 points on a symbol map. We had to plot more than 900,000 addresses. Datawrapper We surveyed the vast landscape of mapping solutions, examining services such as Felt and Protomaps . Ultimately we settled on MapTiler , a Swiss company. MapTiler offered a flexible—and most importantly, tracker-free—suite of tools for hosting and styling map data. Their privacy policy clearly documents the information they collect and where, even specifying they only hold IP addresses of visitors in their memory for a short time before destroying them. Felt Protomaps MapTiler privacy policy And unlike some proprietary products, MapTiler sources its base map from OpenStreetMap , an open-source collection of geographic data. OpenStreetMap As part of the investigation, Leon collected addresses from two open-source datasets, OpenAddresses and NYC OpenData , both of which came with latitude and longitude coordinates assigned to each street address. We used the command line tool tippecanoe to transform these addresses into vector tiles, carving up address locations into smaller subsets which could be quickly loaded in the browser. OpenAddresses NYC OpenData tippecanoe Finally, we used MapLibre GL JS , an open-source derivative of Mapbox’s mapping library, to display the base map and address tiles on our website. We added features such as a tooltip with the details of every address, and filters to isolate neighborhoods by demographics. MapLibre GL JS The end result , which was published on May 11, reveals the stark disparities in internet speeds in major urban areas across the country. We hope it will open up a new frontier of Markup maps. end result By Joel Eastwood By Joel Eastwood Joel Eastwood Also published here Also published here here Photo by Andrew Neel on Unsplash Photo by Andrew Neel on Unsplash Andrew Neel Unsplash

Our Maps Can't Find You

Understanding Dynamic Polymorphism in C++ Dynamic polymorphism is a fundamental principle in object-oriented programming, allowing objects to be treated uniformly while exhibiting different behaviors. This feature is crucial for achieving flexibility and reusability in software design. In this article, we'll explore dynamic polymorphism with a sample program, explain heap and stack memory, delve into the virtual table (vtable), and discuss memory consumption details. Achieving Dynamic Polymorphism in C++ To demonstrate dynamic polymorphism, consider the following example in C++: #include <iostream>

// Base class
class Animal {
public:
    virtual void makeSound() const {
        std::cout << "Animal sound" << std::endl;
    }
    virtual ~Animal() = default; // Virtual destructor
};

// Derived class
class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof" << std::endl;
    }
};

// Another derived class
class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Meow" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->makeSound(); // Outputs: Woof
    animal2->makeSound(); // Outputs: Meow

    return 0;
} In this example, Animal is the base class with a virtual method makeSound(). The Dog and Cat classes override this method. At runtime, the appropriate method is called based on the actual object type (Dog or Cat), demonstrating dynamic polymorphism. C Variant To understand how this is achieved in C, let's recreate the same program: #include <stdio.h>
#include <stdlib.h>

char const* dogSound(void){return "Woof!";}
char const* catSound(void){return "Meow!";}

typedef struct Animal{
    char const * (*makeSound)(); //function pointer
}Animal;

void makeSound(Animal * self){
    printf("%s\n",self->makeSound());
}

Animal * constructDog(){
    Animal * dog = malloc(sizeof(Animal));
    dog->makeSound = dogSound;
    return dog;
}

Animal * constructCat(){
    Animal * cat = malloc(sizeof(Animal));
    cat->makeSound = catSound;
    return cat;
}

int main(void){
    Animal * cat = constructCat(); 
    Animal * dog = constructDog();

    makeSound(cat); // Outputs: Woof
    makeSound(dog); // Outputs: Meow
    return 0;
} Here, function pointers are used to achieve polymorphism in C. The Animal struct contains a function pointer makeSound, which is assigned appropriate functions (dogSound or catSound) at runtime. Heap and Stack Explanation In the sample program, objects animal1 and animal2 are created using the new keyword. This means they are allocated on the heap, which is a region of memory used for dynamic memory allocation. The delete keyword is used to deallocate memory, preventing memory leaks. Conversely, if we had created objects without the new keyword (i.e., Dog dog;), they would be allocated on the stack. The stack is used for static memory allocation, which is automatically managed and has a smaller, faster access compared to the heap. Vtable (Virtual Table) The vtable (virtual table) is a mechanism used by C++ to support dynamic polymorphism. It is a table of function pointers maintained per class. Each class with virtual functions has a corresponding vtable, and each object has a pointer to this vtable, known as the vptr (virtual pointer). When a virtual function is called on an object, the compiler uses the vptr to look up the correct function in the vtable and invoke it. This lookup allows C++ to resolve the function call at runtime, enabling dynamic polymorphism. Memory Consumption Memory consumption in dynamic polymorphism involves both the heap (for dynamic allocation) and the memory overhead of maintaining vtables and vptrs. Each object with virtual functions contains an additional pointer (vptr), and each class with virtual functions has an associated vtable. While the heap allocation allows flexibility, it comes with a cost: dynamic memory management can lead to fragmentation, and improper deallocation can cause memory leaks. Additionally, the indirection through vtables can introduce a slight performance overhead due to the extra pointer dereference. Conclusion Dynamic polymorphism in C++ is a powerful feature that enables flexibility and reusability in object-oriented design. It is achieved through virtual functions, heap allocation, and the use of vtables. Understanding the memory implications and how the heap and stack work is essential for efficient programming in C++. By following best practices in memory management and being mindful of the costs associated with dynamic polymorphism, developers can harness their full potential to create robust and maintainable software. Understanding Dynamic Polymorphism in C++ Dynamic polymorphism is a fundamental principle in object-oriented programming, allowing objects to be treated uniformly while exhibiting different behaviors. This feature is crucial for achieving flexibility and reusability in software design. In this article, we'll explore dynamic polymorphism with a sample program, explain heap and stack memory, delve into the virtual table (vtable), and discuss memory consumption details. Achieving Dynamic Polymorphism in C++ To demonstrate dynamic polymorphism, consider the following example in C++ : C++ #include <iostream>

// Base class
class Animal {
public:
    virtual void makeSound() const {
        std::cout << "Animal sound" << std::endl;
    }
    virtual ~Animal() = default; // Virtual destructor
};

// Derived class
class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof" << std::endl;
    }
};

// Another derived class
class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Meow" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->makeSound(); // Outputs: Woof
    animal2->makeSound(); // Outputs: Meow

    return 0;
} #include <iostream>

// Base class
class Animal {
public:
    virtual void makeSound() const {
        std::cout << "Animal sound" << std::endl;
    }
    virtual ~Animal() = default; // Virtual destructor
};

// Derived class
class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof" << std::endl;
    }
};

// Another derived class
class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Meow" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->makeSound(); // Outputs: Woof
    animal2->makeSound(); // Outputs: Meow

    return 0;
} In this example, Animal is the base class with a virtual method makeSound() . The Dog and Cat classes override this method. At runtime, the appropriate method is called based on the actual object type ( Dog or Cat ), demonstrating dynamic polymorphism. Animal makeSound() Dog Cat Dog Cat C Variant C Variant To understand how this is achieved in C, let's recreate the same program: #include <stdio.h>
#include <stdlib.h>

char const* dogSound(void){return "Woof!";}
char const* catSound(void){return "Meow!";}

typedef struct Animal{
    char const * (*makeSound)(); //function pointer
}Animal;

void makeSound(Animal * self){
    printf("%s\n",self->makeSound());
}

Animal * constructDog(){
    Animal * dog = malloc(sizeof(Animal));
    dog->makeSound = dogSound;
    return dog;
}

Animal * constructCat(){
    Animal * cat = malloc(sizeof(Animal));
    cat->makeSound = catSound;
    return cat;
}

int main(void){
    Animal * cat = constructCat(); 
    Animal * dog = constructDog();

    makeSound(cat); // Outputs: Woof
    makeSound(dog); // Outputs: Meow
    return 0;
} #include <stdio.h>
#include <stdlib.h>

char const* dogSound(void){return "Woof!";}
char const* catSound(void){return "Meow!";}

typedef struct Animal{
    char const * (*makeSound)(); //function pointer
}Animal;

void makeSound(Animal * self){
    printf("%s\n",self->makeSound());
}

Animal * constructDog(){
    Animal * dog = malloc(sizeof(Animal));
    dog->makeSound = dogSound;
    return dog;
}

Animal * constructCat(){
    Animal * cat = malloc(sizeof(Animal));
    cat->makeSound = catSound;
    return cat;
}

int main(void){
    Animal * cat = constructCat(); 
    Animal * dog = constructDog();

    makeSound(cat); // Outputs: Woof
    makeSound(dog); // Outputs: Meow
    return 0;
} Here, function pointers are used to achieve polymorphism in C. The Animal struct contains a function pointer makeSound , which is assigned appropriate functions ( dogSound or catSound ) at runtime. Animal makeSound dogSound catSound Heap and Stack Explanation In the sample program, objects animal1 and animal2 are created using the new keyword. This means they are allocated on the heap, which is a region of memory used for dynamic memory allocation. The delete keyword is used to deallocate memory, preventing memory leaks. animal1 animal2 new delete Conversely, if we had created objects without the new keyword (i.e., Dog dog; ), they would be allocated on the stack. The stack is used for static memory allocation, which is automatically managed and has a smaller, faster access compared to the heap. new Dog dog; Vtable (Virtual Table) The vtable (virtual table) is a mechanism used by C++ to support dynamic polymorphism. It is a table of function pointers maintained per class. Each class with virtual functions has a corresponding vtable, and each object has a pointer to this vtable, known as the vptr (virtual pointer). When a virtual function is called on an object, the compiler uses the vptr to look up the correct function in the vtable and invoke it. This lookup allows C++ to resolve the function call at runtime, enabling dynamic polymorphism. Memory Consumption Memory consumption in dynamic polymorphism involves both the heap (for dynamic allocation) and the memory overhead of maintaining vtables and vptrs. Each object with virtual functions contains an additional pointer (vptr), and each class with virtual functions has an associated vtable. While the heap allocation allows flexibility, it comes with a cost: dynamic memory management can lead to fragmentation, and improper deallocation can cause memory leaks. Additionally, the indirection through vtables can introduce a slight performance overhead due to the extra pointer dereference. Conclusion Dynamic polymorphism in C++ is a powerful feature that enables flexibility and reusability in object-oriented design. It is achieved through virtual functions, heap allocation, and the use of vtables. Understanding the memory implications and how the heap and stack work is essential for efficient programming in C++. By following best practices in memory management and being mindful of the costs associated with dynamic polymorphism, developers can harness their full potential to create robust and maintainable software.

Understanding Dynamic Polymorphism in C++

Streamlining Kafka Integration Testing: Isolation with Testcontainers and Spring Boot 3.1

Authors:
(1) Benzar Glen S. Grepon, Northern Bukidnon State College, Philippines ben.it2c@gmail.com (corresponding author);
(2) JC P. Margallo, Northern Bukidnon State College, Philippines;
(3) Jonathan B. Maserin, Northern Bukidnon State College, Philippines;
(4) Rio Al-Di A. Dompol, Northern Bukidnon State College, Philippines. Table of Links Abstract and Intro Literature Review Methodology Results Discussions Conclusions Recommendations Research Implications Practical Implications Declarations References and Author's Biography DISCUSSIONS This study intent to design, develop and evaluate a web-based roads update information system as an instrument that can be used by anybody who wishes to know the current situation of a particular road in a specific place. Figure 2 shows the over-all System Architecture of the study, where we can see the conceptual model, which defines its structure, behavior, and more views of the developed system; in the case of this study, there are three (2) external entities that can access the API set by the proponents for front end use. For this system to function, a working internet connection is necessary in syncing the Front-end, API, and access to the data and information in the database. System screenshots and system views are presented in Figures 3, 4, 5, and 6. Figure 3 requires the Login of an administrator to have access to the system to control malicious use and to verify that all contributors are legit users to avoid inaccurate updates. The Homepage in Figure 4 shows the home page of the web application by accessing through Smart Phone's browser, Laptop, and Computer. It is the landing page of a web application that the users can access. It contains the search location bar to search the old posts. Traffic alerts include the reports submitted to the users. The recent road updates include the type of incident, location, and time. Location maps are specialized maps dedicated to finding a specific place, while Figure 5 shows the report information page, allowing users to post information about a particular incident. The admin will review the report information to determine if the report is valid and concise. If the reviewed post were approved, it would be shown as a recent road update. Figure 6 shows the Admin Dashboard, where all approvals and management of the road updates are done. The Administrator has the discretion whether to approve or disapprove a particular report of road cases by a citizen because the admin needs to verify whether the claims are valid to avoid possible confusion if all case reports are just done without a reasonable basis. In terms of the evaluation results, table 1 shows a very interesting result. The respondents of this study are drivers, commuters, and travelers. During the evaluation of the regular users, it gives the feedback score about the system of the final output. ISO/IEC 25010 is used for the application evaluation assigned to the participants. The developed web application was evaluated and highly accepted average which is 4.21. Functionality suitability with a mean of 4.00, which is "Very Good", the degree to which a product or system provides functions accomplished defined and suggested needs when used under specified conditions; performance efficiency has a mean of 4.0, which is "Very Good", the performance relative to the amount of resources used under stated conditions; compatibility has a mean of 4.0, which is "Very good" the system can interchange details with other goods, systems/structure or elements, and/or carryout its necessary functions while sharing the same hardware or software environment, usability has a mean of 4.6 which is "Excellent", the system can be used by specified users to achieve established goals with efficacy, efficiency and satisfaction in a specified context of use, reliability has a mean of 4.5 which is "Excellent", It performs designated functions under specified state for a specified period of time, security has a mean of 4.5 which is "Excellent", the system safeguard information and data so that entities such as persons or other commodity or systems/modules have the standard of data access suitable to their types and levels of authorization. , maintainability has a mean of 4.5, the potency and efficiency with which a product/commodity or systems/modules can be change to improve, correct, or adapt it to changes in the environment, and requirements and portability have a mean of 4.5 which is "Excellent"- the system can be transferred from one hardware, software or other operational or usage environment to another. The overall average weighted mean of the application is 4.21, which was rated as "Excellent". This means that application is acceptable during the evaluation. This paper is available on arxiv under CC 4.0 license. Authors: (1) Benzar Glen S. Grepon, Northern Bukidnon State College, Philippines ben.it2c@gmail.com (corresponding author); (2) JC P. Margallo, Northern Bukidnon State College, Philippines; (3) Jonathan B. Maserin, Northern Bukidnon State College, Philippines; (4) Rio Al-Di A. Dompol, Northern Bukidnon State College, Philippines. Authors: Authors: (1) Benzar Glen S. Grepon, Northern Bukidnon State College, Philippines ben.it2c@gmail.com (corresponding author); (2) JC P. Margallo, Northern Bukidnon State College, Philippines; (3) Jonathan B. Maserin, Northern Bukidnon State College, Philippines; (4) Rio Al-Di A. Dompol, Northern Bukidnon State College, Philippines. Table of Links Abstract and Intro Abstract and Intro Literature Review Literature Review Methodology Methodology Results Results Discussions Discussions Conclusions Conclusions Recommendations Recommendations Research Implications Research Implications Practical Implications Practical Implications Declarations Declarations References and Author's Biography References and Author's Biography DISCUSSIONS This study intent to design, develop and evaluate a web-based roads update information system as an instrument that can be used by anybody who wishes to know the current situation of a particular road in a specific place. Figure 2 shows the over-all System Architecture of the study, where we can see the conceptual model, which defines its structure, behavior, and more views of the developed system; in the case of this study, there are three (2) external entities that can access the API set by the proponents for front end use. For this system to function, a working internet connection is necessary in syncing the Front-end, API, and access to the data and information in the database. System screenshots and system views are presented in Figures 3, 4, 5, and 6. Figure 3 requires the Login of an administrator to have access to the system to control malicious use and to verify that all contributors are legit users to avoid inaccurate updates. The Homepage in Figure 4 shows the home page of the web application by accessing through Smart Phone's browser, Laptop, and Computer. It is the landing page of a web application that the users can access. It contains the search location bar to search the old posts. Traffic alerts include the reports submitted to the users. The recent road updates include the type of incident, location, and time. Location maps are specialized maps dedicated to finding a specific place, while Figure 5 shows the report information page, allowing users to post information about a particular incident. The admin will review the report information to determine if the report is valid and concise. If the reviewed post were approved, it would be shown as a recent road update. Figure 6 shows the Admin Dashboard, where all approvals and management of the road updates are done. The Administrator has the discretion whether to approve or disapprove a particular report of road cases by a citizen because the admin needs to verify whether the claims are valid to avoid possible confusion if all case reports are just done without a reasonable basis. In terms of the evaluation results, table 1 shows a very interesting result. The respondents of this study are drivers, commuters, and travelers. During the evaluation of the regular users, it gives the feedback score about the system of the final output. ISO/IEC 25010 is used for the application evaluation assigned to the participants. The developed web application was evaluated and highly accepted average which is 4.21. Functionality suitability with a mean of 4.00, which is "Very Good", the degree to which a product or system provides functions accomplished defined and suggested needs when used under specified conditions; performance efficiency has a mean of 4.0, which is "Very Good", the performance relative to the amount of resources used under stated conditions; compatibility has a mean of 4.0, which is "Very good" the system can interchange details with other goods, systems/structure or elements, and/or carryout its necessary functions while sharing the same hardware or software environment, usability has a mean of 4.6 which is "Excellent", the system can be used by specified users to achieve established goals with efficacy, efficiency and satisfaction in a specified context of use, reliability has a mean of 4.5 which is "Excellent", It performs designated functions under specified state for a specified period of time, security has a mean of 4.5 which is "Excellent", the system safeguard information and data so that entities such as persons or other commodity or systems/modules have the standard of data access suitable to their types and levels of authorization. , maintainability has a mean of 4.5, the potency and efficiency with which a product/commodity or systems/modules can be change to improve, correct, or adapt it to changes in the environment, and requirements and portability have a mean of 4.5 which is "Excellent"- the system can be transferred from one hardware, software or other operational or usage environment to another. The overall average weighted mean of the application is 4.21, which was rated as "Excellent". This means that application is acceptable during the evaluation. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Building a Web-Based Roads Update Information System: Design, Development, and Evaluation

Authors:
(1) Benzar Glen S. Grepon, Northern Bukidnon State College, Philippines ben.it2c@gmail.com (corresponding author);
(2) JC P. Margallo, Northern Bukidnon State College, Philippines;
(3) Jonathan B. Maserin, Northern Bukidnon State College, Philippines;
(4) Rio Al-Di A. Dompol, Northern Bukidnon State College, Philippines. Table of Links Abstract and Intro Literature Review Methodology Results Discussions Conclusions Recommendations Research Implications Practical Implications Declarations References and Author's Biography METHODOLOGY Software Development Over the years, SDLC has remained the reliable approach to software development (Khan et al., 2020). The Agile technique, as indicated in Figure 1, is ideally suited for speedy and effective software development due to its adaptive nature, early delivery, and flexible lifecycle (Srivastava, Bhardwaj & Saraswat, 2017). Planning The researchers obtained data in a Municipality of Bukidnon. They examined the typical issues they ran into. According to the report, many people have accidents because they lack information; thus, they require information to warn them of accident-prone areas, roadblocks, and on-going construction. Requirements Analysis To analyze the requirements using some of the many system flow diagrams and flow charts available. Data flow diagrams are used to represent the flow and to help advocates better understand how to put systems into place and ensure that data is flowing accurately. Additionally, flowcharts are used to demonstrate the system's process, which aids the proponents in making clear how things will operate. The process that needs to be carried out in an operation is depicted using a flowchart as a series of steps. Design In this phase, the researcher plans to make a good design for the project. The researcher surveyed random riders and commuters to gather data information to collect the essential needs of this system. The proponents came up with a functional design of the Network Infrastructure, a framework for the specification of a network's physical components and their functional organization and configuration; the System Architecture, which is the conceptual model that defines the structure, behavior, and more views of a system, the Database Model that determines the logical structure of a database and fundamentally determines in which manner data can be stored. Coding In this phase, the development and writing of the actual code, the researcher uses WordPress to develop web apps; WordPress is the most popular open-source Content Management System (CMS), used by approximately 75 million websites. The researcher studied the hypertext processor (PHP) as the programming language used for web development. The researcher also uses CSS cascading style sheets for creative design to look better. Lastly is JavaScript (JS) for animation and interaction. User Testing The researcher must repeat this procedure until no errors are identified in the functionality of the software development at this stage, where it involves the designing and coding processes. Acceptance for the Client The researchers presented the output web application to propose a random user for acceptance through mobile browser demonstration with System Evaluation Scale (SUS). A mobile browser demonstration will be used as the introductory and brief flow of the application. System Testing and Evaluation During the evaluation of the regular users, it gives the feedback score about the system of the final output. ISO/IEC 25010 is used for the application evaluation assigned to the participants because this ISO Standard provides a uniform vocabulary for defining, assessing, and comparing the quality of systems and software products. Table 1. The Likert table for qualitative interpretation is used in interpreting the results of the survey. Formula: Over-all Average = Total Average/Total Number of Items Equation 1 Table 2 is the ISO overall result for the application quality evaluation. By getting the total average, the researchers used the following formula. This paper is available on arxiv under CC 4.0 license. Authors: (1) Benzar Glen S. Grepon, Northern Bukidnon State College, Philippines ben.it2c@gmail.com (corresponding author); (2) JC P. Margallo, Northern Bukidnon State College, Philippines; (3) Jonathan B. Maserin, Northern Bukidnon State College, Philippines; (4) Rio Al-Di A. Dompol, Northern Bukidnon State College, Philippines. Authors: Authors: (1) Benzar Glen S. Grepon, Northern Bukidnon State College, Philippines ben.it2c@gmail.com (corresponding author); (2) JC P. Margallo, Northern Bukidnon State College, Philippines; (3) Jonathan B. Maserin, Northern Bukidnon State College, Philippines; (4) Rio Al-Di A. Dompol, Northern Bukidnon State College, Philippines. Table of Links Abstract and Intro Abstract and Intro Literature Review Literature Review Methodology Methodology Results Results Discussions Discussions Conclusions Conclusions Recommendations Recommendations Research Implications Research Implications Practical Implications Practical Implications Declarations Declarations References and Author's Biography References and Author's Biography METHODOLOGY Software Development Software Development Over the years, SDLC has remained the reliable approach to software development (Khan et al., 2020). The Agile technique, as indicated in Figure 1, is ideally suited for speedy and effective software development due to its adaptive nature, early delivery, and flexible lifecycle (Srivastava, Bhardwaj & Saraswat, 2017). Planning Planning The researchers obtained data in a Municipality of Bukidnon. They examined the typical issues they ran into. According to the report, many people have accidents because they lack information; thus, they require information to warn them of accident-prone areas, roadblocks, and on-going construction. Requirements Analysis Requirements Analysis To analyze the requirements using some of the many system flow diagrams and flow charts available. Data flow diagrams are used to represent the flow and to help advocates better understand how to put systems into place and ensure that data is flowing accurately. Additionally, flowcharts are used to demonstrate the system's process, which aids the proponents in making clear how things will operate. The process that needs to be carried out in an operation is depicted using a flowchart as a series of steps. Design Design In this phase, the researcher plans to make a good design for the project. The researcher surveyed random riders and commuters to gather data information to collect the essential needs of this system. The proponents came up with a functional design of the Network Infrastructure, a framework for the specification of a network's physical components and their functional organization and configuration; the System Architecture, which is the conceptual model that defines the structure, behavior, and more views of a system, the Database Model that determines the logical structure of a database and fundamentally determines in which manner data can be stored. Coding Coding In this phase, the development and writing of the actual code, the researcher uses WordPress to develop web apps; WordPress is the most popular open-source Content Management System (CMS), used by approximately 75 million websites. The researcher studied the hypertext processor (PHP) as the programming language used for web development. The researcher also uses CSS cascading style sheets for creative design to look better. Lastly is JavaScript (JS) for animation and interaction. User Testing User Testing The researcher must repeat this procedure until no errors are identified in the functionality of the software development at this stage, where it involves the designing and coding processes. Acceptance for the Client Acceptance for the Client The researchers presented the output web application to propose a random user for acceptance through mobile browser demonstration with System Evaluation Scale (SUS). A mobile browser demonstration will be used as the introductory and brief flow of the application. System Testing and Evaluation System Testing and Evaluation During the evaluation of the regular users, it gives the feedback score about the system of the final output. ISO/IEC 25010 is used for the application evaluation assigned to the participants because this ISO Standard provides a uniform vocabulary for defining, assessing, and comparing the quality of systems and software products. Table 1. The Likert table for qualitative interpretation is used in interpreting the results of the survey. Formula: Over-all Average = Total Average/Total Number of Items Equation 1 Over-all Average = Total Average/Total Number of Items Equation 1 Table 2 is the ISO overall result for the application quality evaluation. By getting the total average, the researchers used the following formula. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

An Agile Approach to Developing Accurate Navigation Systems for Road Safety

সড়ক নিরাপত্তার জন্য সঠিক নেভিগেশন সিস্টেম বিকাশে চটপটে দৃষ্টিভঙ্গি

Agiler Ansatz bei der Entwicklung präziser Navigationssysteme für die Verkehrssicherheit

Enfoque ágil en el desarrollo de sistemas de navegación precisos para la seguridad vial

Approche agile dans le développement de systèmes de navigation précis pour la sécurité routière

सड़क सुरक्षा के लिए सटीक नेविगेशन सिस्टम विकसित करने में चुस्त दृष्टिकोण

道路安全のための正確なナビゲーション システムの開発におけるアジャイル アプローチ

도로 안전을 위한 정확한 내비게이션 시스템 개발에 대한 민첩한 접근 방식

Abordagem Ágil no Desenvolvimento de Sistemas de Navegação Precisos para Segurança Rodoviária

Гибкий подход к разработке точных навигационных систем для обеспечения безопасности дорожного движения

Yol Güvenliği İçin Doğru Navigasyon Sistemlerinin Geliştirilmesinde Çevik Yaklaşım

Phương pháp tiếp cận linh hoạt trong việc phát triển hệ thống định vị chính xác cho an toàn đường bộ

敏捷方法开发道路安全精确导航系统

Deploying data science and machine learning applications often demands powerful computational resources. In this guide, You will learn about  the process of setting up GPU-enabled virtual servers on a Virtual Private Cloud (VPC) using Cloud services. By leveraging RAPIDS, an open-source suite of data science libraries developed by NVIDIA, you can harness the power of GPUs to accelerate your workflows. RAPIDS utilizes NVIDIA GPUs to provide high-performance data processing and machine learning capabilities, significantly reducing computation times. This post provides a step-by-step tutorial, from configuring your virtual servers to deploying RAPIDS, ensuring you have the necessary tools and knowledge to optimize your data processing tasks efficiently in a cloud environment. The GPU-enabled family of profiles provides on-demand, cost-effective access to NVIDIA GPUs. GPUs help to accelerate the processing time required for compute-intensive workloads, such as artificial intelligence (AI), machine learning, inferencing and more. To use the GPUs, you need the appropriate toolchain — such as CUDA (an acronym for Compute Unified Device Architecture) — ready. Let’s start with a simple question. What is a GPU and how is it different from CPU? Graphics processing units (GPUs) are becoming more prevalent as accelerated computing is rapidly changing the modern enterprise. They support new applications that are resource-demanding and provide new capabilities to gain valuable insights from customer data. Let’s quickly go over why you could use GPUs in the first place. By operating in a cloud environment, GPUs work in conjunction with a server’s CPU to accelerate application and processing performance. The CPU offloads compute-intensive portions of the application to the GPU, which processes large blocks of data at one time (rather than sequentially) to boost overall performance in a server environment. The following video covers the basics about GPUs, including the differences between a GPU and CPU, the top GPU applications (including industry examples) and why it’s beneficial to use GPUs on cloud infrastructure: What is RAPIDS? The RAPIDS suite of open-source software libraries and APIs give you the ability to execute end-to-end data science and analytics pipelines entirely on GPUs. RAPIDS utilizes NVIDIA CUDA primitives for low-level compute optimization and exposes GPU parallelism and high-bandwidth memory speed through user-friendly Python interfaces. Here are the features of RAPIDS as described on the NVIDIA developer website: Hassle-free integration: Accelerate your Python data-science toolchain with minimal code changes and no new tools to learn.
Top model accuracy: Increase machine-learning model accuracy by iterating on models faster and deploying them more frequently.
Reduced training time: Drastically improve your productivity with near-interactive data science.
Open source: Customizable, extensible, interoperable — the open-source software is supported by NVIDIA and built on Apache Arrow. How to provision a GPU-enabled VSI You will provision a virtual private cloud (VPC), a subnet, a security group with inbound and outbound rules and a virtual service instance (VSI) with a GPU-enabled profile using Terraform scripts with IBM Cloud Schematics. The RAPIDS, along with Docker, are configured via the VSI’s userdata field. VPC uses cloud-init technology to configure virtual server instances. The User Data field on the new virtual server for VPC page allows users to put in custom configuration options by using cloud-init. Cloud-init supports several formats for configuration data, including yaml in a cloud-config file. To understand more about Terraform and IBM Schematics, check this blog post: “ Provision Multiple Instances in a VPC Using Schematics.” In short, you can run any Terraform script just by simply pointing to the Git repository with the scripts. Note: You will need an IBM Cloud account with permissions to provision VPC resources. Check the getting started with VPC documentation. Navigate to Schematics Workspaces on IBM Cloud and click on Create workspace.


Under the Specify Template section, provide https://github.com/IBM-Cloud/vpc-tutorials/tree/master/vpc-gpu-vsi under GitHub or GitLab repository URL.


Select terraform_v0.14 as the Terraform version and click Next.


Provide the workspace name — vpc-gpu-rapids - and choose a resource group and location.


Click Next and then click Create.


You should see the Terraform variables section. Fill in the variables as per your requirement by clicking the action menu next to each of the variables: 7. Scroll to the top of the page to Generate (terraform plan) and Apply (terraform apply) the changes. 8. Click Apply plan and check the progress under the Log. (Generate plan is optional.) In the output of the log, you should see the IP_ADDRESS assigned to the VSI. Save the address for future reference. Test the setup Open a terminal. To test the setup, you need to SSH into the VSI with the below command: ssh -i ~/.ssh/<SSH_PRIVATE_KEY> root@<IP_ADDRESS> A working setup can be tested by running a base CUDA container: sudo docker run — rm — gpus all nvidia/cuda:11.0-base nvidia-smi The output should look similar to this: To check the NVIDIA driver version, run the below command: cat /proc/driver/nvidia/version Output: NVRM version: NVIDIA UNIX x86_64 Kernel Module 470.57.02 Tue Jul 13 16:14:05 UTC 2021

GCC version: gcc version 9.3.0 (Ubuntu 9.3.0–17ubuntu1~20.04) If you don’t see the expected output, check the troubleshooting section of the post. How to use RAPIDS The RAPIDS notebooks are one of the ways to explore the capabilities. These Jupyter notebooks provide examples of how to use RAPIDS. These notebooks are designed to be self-contained with the runtime version of the RAPIDS Docker Container. Run the below commands to pull a Docker image and run a container to explore RAPIDS: docker pull rapidsai/rapidsai:cuda11.0-runtime-ubuntu20.04 docker run — gpus all — rm -it -p 8888:8888 -p 8787:8787 -p 8786:8786 rapidsai/rapidsai:cuda11.0-runtime-ubuntu20.04 2. Launch a browser and enter your <IP_ADDRESS>:8888. 3. You should see the Jupyter notebook: 4. On the left pane, click on notebooks > cuml > tools and then launch the notebook. This notebook provides a simple and unified means of benchmarking single GPU cuML algorithms against their skLearn counterparts with the cuml.benchmark package in RAPIDS cuML. 5. As shown in the image above, click on the icon to launch the GPU dashboards. These dashboards provide a real-time visualization of NVIDIA GPU metrics in interactive Jupyter environments. 6. Click on GPU Resources and Machine Resources to launch the respective dashboards. 7. Run each code cell in the Jupyter notebook until you see the Nearest Neighbors — Brute Force cell. 8. Run the cell and check the metrics on the GPU resources and Machine Resources dashboard to understand the GPU utilization metrics and CPU metrics, respectively: Below the cell, you can check the CPU vs. GPU benchmark metrics. Troubleshooting To check the cloud-init logs, run the following command: cat /var/log/cloud-init-output.log If the install is configured successfully, you should see a message similar to this: _Cloud-init v. 21.2-3-g899bfaa9-0ubuntu2~20.04.1 running 'modules:final'_ _at Thu, 23 Sep 2021 08:51:11 +0000. Up 36.08 seconds._

_Cloud-init v. 21.2-3-g899bfaa9-0ubuntu2~20.04.1 finished at Thu, 23 Sep 2021 08:59:30 +0000. Datasource DataSourceNoCloud [seed=/dev/vdb][dsmode=net]. Up 534.16 seconds_ Related information RAPIDS getting started
Securely access remote instances with a bastion host If you have any queries, feel free to reach out to me on Twitter or on LinkedIn. Deploying data science and machine learning applications often demands powerful computational resources. In this guide, You will learn about  the process of setting up GPU-enabled virtual servers on a Virtual Private Cloud (VPC) using Cloud services. By leveraging RAPIDS, an open-source suite of data science libraries developed by NVIDIA, you can harness the power of GPUs to accelerate your workflows. RAPIDS utilizes NVIDIA GPUs to provide high-performance data processing and machine learning capabilities, significantly reducing computation times. This post provides a step-by-step tutorial, from configuring your virtual servers to deploying RAPIDS, ensuring you have the necessary tools and knowledge to optimize your data processing tasks efficiently in a cloud environment. The GPU-enabled family of profiles provides on-demand, cost-effective access to NVIDIA GPUs. GPUs help to accelerate the processing time required for compute-intensive workloads, such as artificial intelligence (AI) , machine learning , inferencing and more. To use the GPUs, you need the appropriate toolchain — such as CUDA (an acronym for Compute Unified Device Architecture) — ready. artificial intelligence (AI) machine learning Let’s start with a simple question. What is a GPU and how is it different from CPU? Graphics processing units (GPUs) are becoming more prevalent as accelerated computing is rapidly changing the modern enterprise. They support new applications that are resource-demanding and provide new capabilities to gain valuable insights from customer data. Let’s quickly go over why you could use GPUs in the first place. By operating in a cloud environment, GPUs work in conjunction with a server’s CPU to accelerate application and processing performance. The CPU offloads compute-intensive portions of the application to the GPU, which processes large blocks of data at one time (rather than sequentially) to boost overall performance in a server environment. The following video covers the basics about GPUs, including the differences between a GPU and CPU, the top GPU applications (including industry examples) and why it’s beneficial to use GPUs on cloud infrastructure: What is RAPIDS? The RAPIDS suite of open-source software libraries and APIs give you the ability to execute end-to-end data science and analytics pipelines entirely on GPUs. RAPIDS utilizes NVIDIA CUDA primitives for low-level compute optimization and exposes GPU parallelism and high-bandwidth memory speed through user-friendly Python interfaces. RAPIDS NVIDIA CUDA Python Here are the features of RAPIDS as described on the NVIDIA developer website: NVIDIA developer Hassle-free integration: Accelerate your Python data-science toolchain with minimal code changes and no new tools to learn. Top model accuracy: Increase machine-learning model accuracy by iterating on models faster and deploying them more frequently. Reduced training time: Drastically improve your productivity with near-interactive data science. Open source: Customizable, extensible, interoperable — the open-source software is supported by NVIDIA and built on Apache Arrow. Hassle-free integration : Accelerate your Python data-science toolchain with minimal code changes and no new tools to learn. Hassle-free integration Top model accuracy : Increase machine-learning model accuracy by iterating on models faster and deploying them more frequently. Top model accuracy machine-learning Reduced training time : Drastically improve your productivity with near-interactive data science. Reduced training time Open source : Customizable, extensible, interoperable — the open-source software is supported by NVIDIA and built on Apache Arrow. Open source How to provision a GPU-enabled VSI You will provision a virtual private cloud (VPC), a subnet, a security group with inbound and outbound rules and a virtual service instance (VSI) with a GPU-enabled profile using Terraform scripts with IBM Cloud Schematics . The RAPIDS, along with Docker, are configured via the VSI’s userdata field. IBM Cloud Schematics VPC uses cloud-init technology to configure virtual server instances. The User Data field on the new virtual server for VPC page allows users to put in custom configuration options by using cloud-init. Cloud-init supports several formats for configuration data, including yaml in a cloud-config file. User Data To understand more about Terraform and IBM Schematics, check this blog post: “ Provision Multiple Instances in a VPC Using Schematics .” In short, you can run any Terraform script just by simply pointing to the Git repository with the scripts. Provision Multiple Instances in a VPC Using Schematics Terraform Note: You will need an IBM Cloud account with permissions to provision VPC resources. Check the getting started with VPC documentation. Note: getting started with VPC Navigate to Schematics Workspaces on IBM Cloud and click on Create workspace. Under the Specify Template section, provide https://github.com/IBM-Cloud/vpc-tutorials/tree/master/vpc-gpu-vsi under GitHub or GitLab repository URL. Select terraform_v0.14 as the Terraform version and click Next. Provide the workspace name — vpc-gpu-rapids - and choose a resource group and location. Click Next and then click Create. You should see the Terraform variables section. Fill in the variables as per your requirement by clicking the action menu next to each of the variables: Navigate to Schematics Workspaces on IBM Cloud and click on Create workspace. Navigate to Schematics Workspaces on IBM Cloud and click on Create workspace. Schematics Workspaces Schematics Workspaces Create workspace. Under the Specify Template section, provide https://github.com/IBM-Cloud/vpc-tutorials/tree/master/vpc-gpu-vsi under GitHub or GitLab repository URL. Under the Specify Template section, provide https://github.com/IBM-Cloud/vpc-tutorials/tree/master/vpc-gpu-vsi under GitHub or GitLab repository URL . Specify Template https://github.com/IBM-Cloud/vpc-tutorials/tree/master/vpc-gpu-vsi GitHub or GitLab repository URL Select terraform_v0.14 as the Terraform version and click Next. Select terraform_v0.14 as the Terraform version and click Next. terraform_v0.14 Next. Provide the workspace name — vpc-gpu-rapids - and choose a resource group and location. Provide the workspace name — vpc-gpu-rapids - and choose a resource group and location. vpc-gpu-rapids Click Next and then click Create. Click Next and then click Create. Next Create. You should see the Terraform variables section. Fill in the variables as per your requirement by clicking the action menu next to each of the variables: You should see the Terraform variables section. Fill in the variables as per your requirement by clicking the action menu next to each of the variables: 7. Scroll to the top of the page to Generate (terraform plan) and Apply (terraform apply) the changes. Generate (terraform plan) Apply (terraform apply) 8. Click Apply plan and check the progress under the Log . (Generate plan is optional.) Apply plan Log In the output of the log, you should see the IP_ADDRESS assigned to the VSI. Save the address for future reference. IP_ADDRESS Test the setup Open a terminal. To test the setup, you need to SSH into the VSI with the below command: Open a terminal. To test the setup, you need to SSH into the VSI with the below command: ssh -i ~/.ssh/<SSH_PRIVATE_KEY> root@<IP_ADDRESS> ssh -i ~/.ssh/<SSH_PRIVATE_KEY> root@<IP_ADDRESS> A working setup can be tested by running a base CUDA container: A working setup can be tested by running a base CUDA container: sudo docker run — rm — gpus all nvidia/cuda:11.0-base nvidia-smi sudo docker run — rm — gpus all nvidia/cuda:11.0-base nvidia-smi The output should look similar to this: To check the NVIDIA driver version, run the below command: To check the NVIDIA driver version, run the below command: cat /proc/driver/nvidia/version cat /proc/driver/nvidia/version Output: NVRM version: NVIDIA UNIX x86_64 Kernel Module 470.57.02 Tue Jul 13 16:14:05 UTC 2021

GCC version: gcc version 9.3.0 (Ubuntu 9.3.0–17ubuntu1~20.04) NVRM version: NVIDIA UNIX x86_64 Kernel Module 470.57.02 Tue Jul 13 16:14:05 UTC 2021

GCC version: gcc version 9.3.0 (Ubuntu 9.3.0–17ubuntu1~20.04) If you don’t see the expected output, check the troubleshooting section of the post. How to use RAPIDS The RAPIDS notebooks are one of the ways to explore the capabilities. These Jupyter notebooks provide examples of how to use RAPIDS. These notebooks are designed to be self-contained with the runtime version of the RAPIDS Docker Container . RAPIDS notebooks RAPIDS Docker Container Run the below commands to pull a Docker image and run a container to explore RAPIDS: Run the below commands to pull a Docker image and run a container to explore RAPIDS: docker pull rapidsai/rapidsai:cuda11.0-runtime-ubuntu20.04 docker pull rapidsai/rapidsai:cuda11.0-runtime-ubuntu20.04 docker run — gpus all — rm -it -p 8888:8888 -p 8787:8787 -p 8786:8786 rapidsai/rapidsai:cuda11.0-runtime-ubuntu20.04 docker run — gpus all — rm -it -p 8888:8888 -p 8787:8787 -p 8786:8786 rapidsai/rapidsai:cuda11.0-runtime-ubuntu20.04 2. Launch a browser and enter your <IP_ADDRESS>:8888 . <IP_ADDRESS>:8888 3. You should see the Jupyter notebook: 4. On the left pane, click on notebooks > cuml > tools and then launch the notebook. This notebook provides a simple and unified means of benchmarking single GPU cuML algorithms against their skLearn counterparts with the cuml.benchmark package in RAPIDS cuML. notebooks cuml tools 5. As shown in the image above, click on the icon to launch the GPU dashboards. These dashboards provide a real-time visualization of NVIDIA GPU metrics in interactive Jupyter environments. GPU dashboards. 6. Click on GPU Resources and Machine Resources to launch the respective dashboards. GPU Resources Machine Resources 7. Run each code cell in the Jupyter notebook until you see the Nearest Neighbors — Brute Force cell. Nearest Neighbors — Brute Force 8. Run the cell and check the metrics on the GPU resources and Machine Resources dashboard to understand the GPU utilization metrics and CPU metrics, respectively: Below the cell, you can check the CPU vs. GPU benchmark metrics. Troubleshooting To check the cloud-init logs, run the following command: cat /var/log/cloud-init-output.log cat /var/log/cloud-init-output.log If the install is configured successfully, you should see a message similar to this: _Cloud-init v. 21.2-3-g899bfaa9-0ubuntu2~20.04.1 running 'modules:final'_ _at Thu, 23 Sep 2021 08:51:11 +0000. Up 36.08 seconds._

_Cloud-init v. 21.2-3-g899bfaa9-0ubuntu2~20.04.1 finished at Thu, 23 Sep 2021 08:59:30 +0000. Datasource DataSourceNoCloud [seed=/dev/vdb][dsmode=net]. Up 534.16 seconds_ _Cloud-init v. 21.2-3-g899bfaa9-0ubuntu2~20.04.1 running 'modules:final'_ _at Thu, 23 Sep 2021 08:51:11 +0000. Up 36.08 seconds._

_Cloud-init v. 21.2-3-g899bfaa9-0ubuntu2~20.04.1 finished at Thu, 23 Sep 2021 08:59:30 +0000. Datasource DataSourceNoCloud [seed=/dev/vdb][dsmode=net]. Up 534.16 seconds_ Related information RAPIDS getting started Securely access remote instances with a bastion host RAPIDS getting started RAPIDS getting started Securely access remote instances with a bastion host Securely access remote instances with a bastion host If you have any queries, feel free to reach out to me on Twitter or on LinkedIn. If you have any queries, feel free to reach out to me on Twitter or on LinkedIn . Twitter LinkedIn

How to Deploy RAPIDs on GPU-Enabled Private Cloud

Authors:
(1) Prerak Gandhi, Department of Computer Science and Engineering, Indian Institute of Technology Bombay, Mumbai, prerakgandhi@cse.iitb.ac.in, and these authors contributed equally to this work;
(2) Vishal Pramanik, Department of Computer Science and Engineering, Indian Institute of Technology Bombay, Mumbai, vishalpramanik,pb@cse.iitb.ac.in, and these authors contributed equally to this work;
(3) Pushpak Bhattacharyya, Department of Computer Science and Engineering, Indian Institute of Technology Bombay, Mumbai. Table of Links Abstract and Intro
Motivation
Related Work
Dataset
Experiments and Evaluation
Results and Analysis
Conclusion and Future Work
Limitations and References
A. Appendix 6. Results and Analysis We present our observations and evaluations. The nature of our task makes human evaluation take precedence over automatic evaluation (it is for automatic movie script generation, after all!). The qualitative analysis of our generated plots and scenes is based on feedback from 5 professional scriptwriters of our industry partner, the well-known media platform. 6.1. Plot Generation 6.1.1. Automatic Evaluation Table 1 shows auto-evaluation scores for the multiple GPT-3 plot generation models. 6.1.2. Human Rating We conducted human evaluation on Hollywood annotated short input model. The evaluation was done by five groups of 3 people, with each group having been assigned 10 unique plots. The ratings given for the 5 features are in Figure 5. The average scores for fluency, creativity, likability, coherence and relevance are 3.98, 3.29, 2.97, 2.65 and 2.55, respectively. Fluency of almost 4 is an indicator of the power of GPT-3 as a language model. Creativity and likeability are respectable at a value of around 3.0. The low BLEU scores support the average creativity score (Table 1). Figure 5 indicates that coherence and relevance still have major room for improvement. The MAUVE (Pillutla et al., 2021) value measures the gap between neural text and human text. We have separately calculated the MAUVE scores for 20 plots and 50 plots. The weighted average of the MAUVE scores for the two experiments is 0.48 which is reasonably good. 6.1.3. Qualitative Observations Professional scriptwriters from our industry partner have given the following observations: Non-annotated Hollywood Plots • The build-up is creative and interesting, but the ending becomes incoherent. • Some characters which are introduced in the beginning are never mentioned again. • The output is not portraying the key points or the theme mentioned in the input. Annotated Hollywood Plots • The plots are much more coherent, and the endings are logical. • There is still hallucination present (a common feature of all models). • The longer inputs made the plots more attentive to the key points. Annotated Hollywood Plots with Genres included • Along with the above points, now the plots generated are more tilted towards the genre or genres of the movie the writer wants to create. • Addition of genre gives some control over the kind of plot generated by the model. Annotated Bollywood plots • The outputs show incoherence in the last two paragraphs and repetition of the same characters throughout the plot. • The flow of the plot is not fast enough, i.e., the plot does not move ahead much. • Many of the outputs have a 1990s theme around them, where the characters are separated and then find each other later. This is due to a skewed dataset with lesser modern plots. 6.2. Scene Generation We fine-tuned GPT-3 for scene generation with our dataset. We generated ten scenes using the models mentioned in 5.1. Figure 7 in the appendix. shows an example of a completely generated scene. 6.2.1. Human Ratings We conducted a human evaluation on 10 scenes generated by the above model. 5 people evaluated the scenes using the Likert Scale. The ratings for the five features can be seen in Figure 5. The average scores for fluency, creativity, likability, coherence, and relevance are 4.48, 3.9, 3.48, 3.46 and 3.86, respectively. All of the values are above the neutral mark and imply that the generated scenes are close to human-written scenes. 6.2.2. Qualitative Observations In this section, we analyze the quality of the scenes generated by the GPT-3 model. This analysis has been done by professional scriptwriters from the previously mentioned media company. • The model produces a well-structured scene. • It can create new characters and fabricate dialogues even when they are unimportant. • The key points from the input can be found in the output. • There are some lines that are repetitive. • The output is not completely coherent. This paper is available on arxiv under CC 4.0 DEED license. Authors: (1) Prerak Gandhi, Department of Computer Science and Engineering, Indian Institute of Technology Bombay, Mumbai, prerakgandhi@cse.iitb.ac.in, and these authors contributed equally to this work; (2) Vishal Pramanik, Department of Computer Science and Engineering, Indian Institute of Technology Bombay, Mumbai, vishalpramanik,pb@cse.iitb.ac.in, and these authors contributed equally to this work; (3) Pushpak Bhattacharyya, Department of Computer Science and Engineering, Indian Institute of Technology Bombay, Mumbai. Authors: Authors: (1) Prerak Gandhi, Department of Computer Science and Engineering, Indian Institute of Technology Bombay, Mumbai, prerakgandhi@cse.iitb.ac.in, and these authors contributed equally to this work; (2) Vishal Pramanik, Department of Computer Science and Engineering, Indian Institute of Technology Bombay, Mumbai, vishalpramanik,pb@cse.iitb.ac.in, and these authors contributed equally to this work; (3) Pushpak Bhattacharyya, Department of Computer Science and Engineering, Indian Institute of Technology Bombay, Mumbai. Table of Links Abstract and Intro Motivation Related Work Dataset Experiments and Evaluation Results and Analysis Conclusion and Future Work Limitations and References A. Appendix Abstract and Intro Abstract and Intro Motivation Motivation Related Work Related Work Dataset Dataset Experiments and Evaluation Experiments and Evaluation Results and Analysis Results and Analysis Conclusion and Future Work Conclusion and Future Work Limitations and References Limitations and References A. Appendix A. Appendix 6. Results and Analysis We present our observations and evaluations. The nature of our task makes human evaluation take precedence over automatic evaluation (it is for automatic movie script generation, after all!). The qualitative analysis of our generated plots and scenes is based on feedback from 5 professional scriptwriters of our industry partner, the well-known media platform. 6.1. Plot Generation 6.1.1. Automatic Evaluation Table 1 shows auto-evaluation scores for the multiple GPT-3 plot generation models. 6.1.2. Human Rating We conducted human evaluation on Hollywood annotated short input model. The evaluation was done by five groups of 3 people, with each group having been assigned 10 unique plots. The ratings given for the 5 features are in Figure 5. The average scores for fluency, creativity, likability, coherence and relevance are 3.98, 3.29, 2.97, 2.65 and 2.55 , respectively. Fluency of almost 4 is an indicator of the power of GPT-3 as a language model. Creativity and likeability are respectable at a value of around 3.0. The low BLEU scores support the average creativity score (Table 1). Figure 5 indicates that coherence and relevance still have major room for improvement. 3.98, 3.29, 2.97, 2.65 2.55 The MAUVE (Pillutla et al., 2021) value measures the gap between neural text and human text. We have separately calculated the MAUVE scores for 20 plots and 50 plots. The weighted average of the MAUVE scores for the two experiments is 0.48 which is reasonably good. 0.48 6.1.3. Qualitative Observations Professional scriptwriters from our industry partner have given the following observations: Non-annotated Hollywood Plots Non-annotated Hollywood Plots • The build-up is creative and interesting, but the ending becomes incoherent. • Some characters which are introduced in the beginning are never mentioned again. • The output is not portraying the key points or the theme mentioned in the input. Annotated Hollywood Plots Annotated Hollywood Plots • The plots are much more coherent, and the endings are logical. • There is still hallucination present (a common feature of all models). • The longer inputs made the plots more attentive to the key points. Annotated Hollywood Plots with Genres included Annotated Hollywood Plots with Genres included • Along with the above points, now the plots generated are more tilted towards the genre or genres of the movie the writer wants to create. • Addition of genre gives some control over the kind of plot generated by the model. Annotated Bollywood plots Annotated Bollywood plots • The outputs show incoherence in the last two paragraphs and repetition of the same characters throughout the plot. • The flow of the plot is not fast enough, i.e., the plot does not move ahead much. • Many of the outputs have a 1990s theme around them, where the characters are separated and then find each other later. This is due to a skewed dataset with lesser modern plots. 6.2. Scene Generation We fine-tuned GPT-3 for scene generation with our dataset. We generated ten scenes using the models mentioned in 5.1. Figure 7 in the appendix. shows an example of a completely generated scene. 6.2.1. Human Ratings We conducted a human evaluation on 10 scenes generated by the above model. 5 people evaluated the scenes using the Likert Scale. The ratings for the five features can be seen in Figure 5. The average scores for fluency, creativity, likability, coherence, and relevance are 4.48, 3.9, 3.48, 3.46 and 3.86 , respectively. All of the values are above the neutral mark and imply that the generated scenes are close to human-written scenes. 4.48, 3.9, 3.48, 3.46 3.86 6.2.2. Qualitative Observations In this section, we analyze the quality of the scenes generated by the GPT-3 model. This analysis has been done by professional scriptwriters from the previously mentioned media company. • The model produces a well-structured scene. • It can create new characters and fabricate dialogues even when they are unimportant. • The key points from the input can be found in the output. • There are some lines that are repetitive. • The output is not completely coherent. This paper is available on arxiv under CC 4.0 DEED license. This paper is available on arxiv under CC 4.0 DEED license. available on arxiv

"Kurosawa": A Script Writer's Assistant: Results and Analysis

"কুরোসাওয়া": একজন স্ক্রিপ্ট লেখকের সহকারী: ফলাফল এবং বিশ্লেষণ

„Kurosawa“: Assistent eines Drehbuchautors: Ergebnisse und Analyse

"Kurosawa": un asistente de guionista: resultados y análisis

"Kurosawa" : un assistant de scénariste : résultats et analyse

"कुरोसावा": एक पटकथा लेखक का सहायक: परिणाम और विश्लेषण

「黒澤」脚本家アシスタント：結果と分析

"쿠로사와": 각본가의 조수: 결과 및 분석

"Kurosawa": um assistente de roteirista: resultados e análises

«Куросава»: помощник сценариста: итоги и анализ

"Kurosawa": Bir Senaryo Yazarının Asistanı: Sonuçlar ve Analiz

"Kurosawa": Trợ lý biên kịch: Kết quả và phân tích

“黑泽明”：编剧助理：结果与分析

The Problem The analytics service faced a unique problem - it needed to process and store millions of requests per day as cheaply as possible. Initially, it was hosted on a simple single-node server, which was a good idea at the start of the project, but now, it needed to scale. The question was how to move to a more flexible architecture as smoothly as possible. Possible Solutions The first thing I thought was "Just add more power to the machine." It's called "vertical scaling." Adding more resources to the server might help in the short term and might even be cost-effective, but it comes with its own caveats. It might also be a bit easier to develop and manage because it relies on only one server.But one server, even a powerful one, would be a single point of failure. This means that if it went down for any reason, the whole system would be inaccessible, which is not acceptable for a high-demand service.The other possible solution would be to split the application into several services, each responsible for its own, dedicated type of task. This could reduce the load on each service, but the problem would be that they would still be relying on vertical scaling alone. It would also be difficult to maintain such an architecture, as everything would now be an individual service, and we would have to set up proper communication between them. It would also lead to a lot of code repetition, make testing and debugging more difficult (remember that each service is not individual, so they all have their own sets of logs and coverage tests), and generally leave us with complex orchestration later on.I believe that microservice architecture works well for large enterprises, where there are sometimes teams dedicated to a single service, but it was just not a good fit for us. The Breakthrough After considering possible architectures, I decided to try replicating our existing application with a few workers and hosting them on individual servers. The approach is similar to NodeJS built-in clustering, but instead of creating workers within a VM, we create them in new VMs.This architecture allows us to scale the VMs vertically or add more servers (horizontal scaling) as needed. It also gives us more flexibility as we can stop, scale up, or scale down any machine at any time. Requests to our server go through a load balancer, which routes the request to the least busy worker. The load balancer is also responsible for managing the HTTPS certificates for the domain itself. If we wanted to do "white label analytics" where each customer could have their own dedicated dashboard, it would be easy to automate this process by assigning certificates with the load balancer and managing the dashboards with Traefik. The database services and workers are now separate and communicate over a private network. This gives us even more flexibility because the storage service and workers are independent, and it also ensures that no one can access the database from the Internet because of strict firewall rules. We can give the databases more available storage without having to scale the worker services. It also makes backups easier. Workers are now assigned different roles - a master worker and a regular worker. They behave in much the same way, except that the master worker must perform scheduled tasks (such as moving analytics data from the cache to the database or preparing email reports) to prevent the same task from being performed by workers.And the services are able to communicate with each other using Redis, which is really helpful for us - when each individual worker receives an analytics request, it can store it in the Redis cache for the master service to process later. Optimizing Performance and Cost The new architecture now processes around 10,000 requests per minute. We've seen a 30% reduction in processing time, which demonstrates the new efficiency and scalability of the system. And the best part is the simplicity - it's easy to maintain, and we can always scale it up or down if we need to.It's also a very affordable solution, with Hetzner charging around £50 per month, whereas a similar setup on GCP would cost us thousands of pounds. The Problem The analytics service faced a unique problem - it needed to process and store millions of requests per day as cheaply as possible. Initially, it was hosted on a simple single-node server, which was a good idea at the start of the project, but now, it needed to scale. The question was how to move to a more flexible architecture as smoothly as possible. Possible Solutions The first thing I thought was "Just add more power to the machine." It's called "vertical scaling." Adding more resources to the server might help in the short term and might even be cost-effective, but it comes with its own caveats. It might also be a bit easier to develop and manage because it relies on only one server. But one server, even a powerful one, would be a single point of failure. This means that if it went down for any reason, the whole system would be inaccessible, which is not acceptable for a high-demand service. The other possible solution would be to split the application into several services, each responsible for its own, dedicated type of task. This could reduce the load on each service, but the problem would be that they would still be relying on vertical scaling alone. It would also be difficult to maintain such an architecture, as everything would now be an individual service, and we would have to set up proper communication between them. It would also lead to a lot of code repetition, make testing and debugging more difficult (remember that each service is not individual, so they all have their own sets of logs and coverage tests), and generally leave us with complex orchestration later on. I believe that microservice architecture works well for large enterprises, where there are sometimes teams dedicated to a single service, but it was just not a good fit for us. The Breakthrough After considering possible architectures, I decided to try replicating our existing application with a few workers and hosting them on individual servers. The approach is similar to NodeJS built-in clustering, but instead of creating workers within a VM, we create them in new VMs. This architecture allows us to scale the VMs vertically or add more servers (horizontal scaling) as needed. It also gives us more flexibility as we can stop, scale up, or scale down any machine at any time. Requests to our server go through a load balancer, which routes the request to the least busy worker. The load balancer is also responsible for managing the HTTPS certificates for the domain itself. If we wanted to do "white label analytics" where each customer could have their own dedicated dashboard, it would be easy to automate this process by assigning certificates with the load balancer and managing the dashboards with Traefik. The database services and workers are now separate and communicate over a private network. This gives us even more flexibility because the storage service and workers are independent, and it also ensures that no one can access the database from the Internet because of strict firewall rules. We can give the databases more available storage without having to scale the worker services. It also makes backups easier. Workers are now assigned different roles - a master worker and a regular worker. They behave in much the same way, except that the master worker must perform scheduled tasks (such as moving analytics data from the cache to the database or preparing email reports) to prevent the same task from being performed by workers. And the services are able to communicate with each other using Redis, which is really helpful for us - when each individual worker receives an analytics request, it can store it in the Redis cache for the master service to process later. Optimizing Performance and Cost The new architecture now processes around 10,000 requests per minute. We've seen a 30% reduction in processing time, which demonstrates the new efficiency and scalability of the system. And the best part is the simplicity - it's easy to maintain, and we can always scale it up or down if we need to. It's also a very affordable solution, with Hetzner charging around £50 per month, whereas a similar setup on GCP would cost us thousands of pounds.

How to Scale NestJS Applications: A Case Study of a High-Load Web Analytics Backend

Stories, News & Mentions about ASSIGNED

Assigned’s Stories on HackerNoon