Welcome to Aetion! Since our debut in 2013, we have grown into one of the country’s leading science-driven technology companies using real-world evidence to provide innovative healthcare solutions

Aetion

aetion

Biden-⁠Harris Administration Commends Federal Agencies for Completing Key AI Actions in 180 Days

বিডেন-হ্যারিস প্রশাসন 180 দিনের মধ্যে মূল এআই অ্যাকশনগুলি সম্পূর্ণ করার জন্য ফেডারেল এজেন্সিগুলির প্রশংসা করেছে

Biden-Harris-Regierung lobt Bundesbehörden für die Umsetzung wichtiger KI-Maßnahmen in 180 Tagen

La administración Biden-⁠Harris elogia a las agencias federales por completar acciones clave de IA en 180 días

L’administration Biden-⁠Harris félicite les agences fédérales pour avoir mené à bien des actions clés en matière d’IA en 180 jours

बिडेन-हैरिस प्रशासन ने 180 दिनों में प्रमुख एआई कार्रवाइयों को पूरा करने के लिए संघीय एजेंसियों की सराहना की

バイデン・ハリス政権、連邦政府機関が180日以内に主要なAI対策を完了したことを称賛

Biden-⁠해리스 행정부, 180일 만에 핵심 AI 작업을 완료한 연방 기관 칭찬

Administração Biden-⁠Harris elogia agências federais por concluírem ações importantes de IA em 180 dias

Администрация Байдена-Харриса благодарит федеральные агентства за завершение ключевых действий в области искусственного интеллекта за 180 дней

Biden-⁠Harris Yönetimi, Temel Yapay Zeka Eylemlerini 180 Günde Tamamlayan Federal Kurumları Övdü

Chính quyền Biden-⁠Harris khen ngợi các cơ quan liên bang đã hoàn thành các hành động quan trọng về AI trong 180 ngày

拜登-哈里斯政府赞扬联邦机构在 180 天内完成关键人工智能行动

Sentience recently made news with The New York Declaration on Animal Consciousness, where consciousness was described as subjective experience. The declaration used observations of similarities of several organisms with human consciousness to make the case. However, the question remains, where is consciousness generated, the brain or the mind? The mind can be described as the part of the cranium directly involved in every information function ascribed to the brain. This means the electrical and chemical signals of neurons. Though often labeled as how neurons communicate, they are postulated to be beyond communication, but the basis of functions. A reason is that they structure and specify information—emotions, feelings, modulations, and memory. They are not passed—like their information contents are made within a neuron and one neuron is passing the information to another. Signals move with neurons as the medium, not that neurons are using signals to communicate, conceptually. Simply, signals are the architecture of information. Though neurons have roles in making them, as ions and molecules, what they do, together in interactions, for information makes them distinct and exceeds mere communication of one neuron to the next—to the actual basis of information—conceptually. The human mind is postulated to be the collection of all the electrical and chemical signals, with their interactions and features, in set. Sets indicate the group of signals obtained in clusters of neurons. Though, some sets may exist away from those. Electrical signals are driven by action potentials. Chemical signals are dominated by neurotransmitters. It is theorized that experience or any function arises when electrical signals in sets strike at chemical signals. This makes the electrical signals provide what they bear and access what the chemical signals hold, before relaying again with it. Electrical signals are ions. Chemical signals are molecules. Ions and molecules interact to form a new state that becomes the basis of experience with the external world and regulation of internal senses, conceptually. Respective chemical signals provide rations that become the configuration for functions. Between their sources, there are spaces that become how they get qualified. Or, how features develop to act on functions. This is where subjectivity, intent, attention and awareness arise from. Functions can be learned, but features are different from functions. For subjective experience to be active, there has to be attention or awareness. Intent may also determine the extent of subjectivity. Subjectivity is included in consciousness—but not central to it. Experiences in the brain are obtained from the actions of ions and molecules. Features are organized by molecules, but can be relayed by ions. AI does not have emotions, feelings or modulation, but it has memory. These features that act on human memory can be used to measure similarities to those of LLMs. Sentience recently made news with The New York Declaration on Animal Consciousness , where consciousness was described as subjective experience. The declaration used observations of similarities of several organisms with human consciousness to make the case. Sentience The New York Declaration on Animal Consciousness However, the question remains, where is consciousness generated, the brain or the mind? The mind can be described as the part of the cranium directly involved in every information function ascribed to the brain. This means the electrical and chemical signals of neurons. Though often labeled as how neurons communicate, they are postulated to be beyond communication, but the basis of functions. A reason is that they structure and specify information—emotions, feelings, modulations, and memory. They are not passed—like their information contents are made within a neuron and one neuron is passing the information to another. Signals move with neurons as the medium, not that neurons are using signals to communicate, conceptually. Simply, signals are the architecture of information. Though neurons have roles in making them, as ions and molecules, what they do, together in interactions, for information makes them distinct and exceeds mere communication of one neuron to the next—to the actual basis of information—conceptually. The human mind is postulated to be the collection of all the electrical and chemical signals, with their interactions and features, in set. Sets indicate the group of signals obtained in clusters of neurons. Though, some sets may exist away from those. Electrical signals are driven by action potentials. Chemical signals are dominated by neurotransmitters. It is theorized that experience or any function arises when electrical signals in sets strike at chemical signals . This makes the electrical signals provide what they bear and access what the chemical signals hold, before relaying again with it. when electrical signals in sets strike at chemical signals Electrical signals are ions. Chemical signals are molecules. Ions and molecules interact to form a new state that becomes the basis of experience with the external world and regulation of internal senses, conceptually. Respective chemical signals provide rations that become the configuration for functions. Between their sources, there are spaces that become how they get qualified. Or, how features develop to act on functions. This is where subjectivity, intent, attention and awareness arise from. Functions can be learned, but features are different from functions. For subjective experience to be active, there has to be attention or awareness. Intent may also determine the extent of subjectivity. Subjectivity is included in consciousness—but not central to it. Experiences in the brain are obtained from the actions of ions and molecules. Features are organized by molecules, but can be relayed by ions. AI does not have emotions, feelings or modulation, but it has memory. These features that act on human memory can be used to measure similarities to those of LLMs.

Sentience: Action Potentials—Neurotransmitters and the Theory of Consciousness

Taking action has been a life-changing decision for me. It has brought a lot of clarity to my life and day-to-day activities. I get a lot of tasks done and improve myself consistently as well. It has put me on the path to slaying complacency, eliminating procrastination, and fulfilling my immense potential. These are four principles of how action breeds clarity, and how I implement them. 1. Learning by Doing Learning by doing stops us from overthinking things. We are only human. We will never be sure of every decision we make. We have an innate tendency to overthink and analyze situations before taking action. Overthinking leads to what is commonly known as "analysis paralysis." It blurs our perspective, creates confusion, and stagnates our progress. Overthinking creates multiple outcomes that lead to increased anxiety, dissatisfaction, and even paralysis. This concept was theorized by psychologist Barry Schwartz in his book “The Paradox of Choice: Why More Is Less.” Schwartz argues that having choices is generally considered a positive aspect of modern life. The abundance of options in various domains—such as career paths and life decisions—can overwhelm individuals and hinder their ability to make effective decisions. We should use our time efficiently and learn in the process. Do not overthink things. Just-In-Time Knowledge Over Just-In-Case Knowledge “Just-in-time knowledge” refers to acquiring skills and information when they are immediately needed for a specific task, problem, or situation. “Just-in-case knowledge” refers to learning skills and information in preparation for future needs. Both approaches have their advantages. Why is this knowledge important? A lot of people read, watch videos, and consume information that they are unlikely to put into practice. This knowledge is more of an entertainment source than it is a learned skill. We are more likely to change a light bulb than apply survival tactics when faced with a lion. There’s nothing wrong with knowing how to survive a lion attack, but it’s very unlikely that you’ll use that knowledge. People who prioritize this type of knowledge are also prone to procrastination. They focus solely on what could happen. This keeps them in an endless cycle of worry and anxiety that prevents them from accomplishing the goals they’ve set for themselves. We prioritize just-in-time knowledge and reference Tim Ferris, who said, “Prefer just-in-time knowledge over just-in-case knowledge.” 3. Do and Reflect Getting things done while learning relevant aspects is good for our growth. Reflection gives us new perspectives of ourselves that allow us to analyze and improve on areas we are weak. It is important to see your goals through. Doing so staves off doubt, depression, and anxiety. It builds your character in the process, putting you in a position to continually improve. Resist the temptation to quit or give up. Do not second-guess yourself by wondering if you should do something else instead. Guard your mind against self-doubt and stay focused on the task at hand. Take action over your patterns, routines, and nuances. Don’t allow complacency to creep in as it can drain you of all your potential, leaving you depressed and unfulfilled. Adapt to changing circumstances and build on routines that make you better. 4. Building Confidence & Embracing the Unknown The action involves stepping into the unknown. Embracing uncertainty allows us to confront fears and doubts that hinder progress. Navigating through uncharted territories is scary and unpleasant. However, doing so builds and grows confidence. This confidence stems from realizing we can overcome challenges and learn from them. Overthinking can create worst-case scenarios that fill us with fear. Fear can hold you back from achieving your potential. Take the leap of faith into the unknown, and overcome the challenges that await you. As David Goggins says, “Embrace the suck!” It might not be pleasurable in the beginning, but you will learn how to deal with it. You’ll master how to navigate uncharted waters and come out the other side stronger than before. Conclusion Action breeds clarity and encapsulates a fundamental truth that transcends various aspects of life. It allows us to break free from the constraints of overthinking. We gain insights, experiences, and wisdom that lead to a clearer understanding of ourselves and our environment. The courage to take action propels us toward our goals while fostering adaptability and self-confidence. Action holds the key to the clarity we seek. The world is your oyster. Stop overthinking and act starting today. For these and more thoughts, guides and insights visit my blog at martinbaun.com Taking action has been a life-changing decision for me. It has brought a lot of clarity to my life and day-to-day activities. I get a lot of tasks done and improve myself consistently as well. It has put me on the path to slaying complacency, eliminating procrastination, and fulfilling my immense potential. These are four principles of how action breeds clarity, and how I implement them. 1. Learning by Doing Learning by doing stops us from overthinking things. We are only human. We will never be sure of every decision we make. We have an innate tendency to overthink and analyze situations before taking action. Overthinking leads to what is commonly known as "analysis paralysis." It blurs our perspective, creates confusion, and stagnates our progress. Overthinking creates multiple outcomes that lead to increased anxiety, dissatisfaction, and even paralysis. This concept was theorized by psychologist Barry Schwartz in his book “The Paradox of Choice: Why More Is Less.” Schwartz argues that having choices is generally considered a positive aspect of modern life. The abundance of options in various domains—such as career paths and life decisions—can overwhelm individuals and hinder their ability to make effective decisions. We should use our time efficiently and learn in the process. Do not overthink things. Just-In-Time Knowledge Over Just-In-Case Knowledge “Just-in-time knowledge” refers to acquiring skills and information when they are immediately needed for a specific task, problem, or situation. “Just-in-case knowledge” refers to learning skills and information in preparation for future needs. Both approaches have their advantages. Why is this knowledge important? A lot of people read, watch videos, and consume information that they are unlikely to put into practice. This knowledge is more of an entertainment source than it is a learned skill. We are more likely to change a light bulb than apply survival tactics when faced with a lion. There’s nothing wrong with knowing how to survive a lion attack, but it’s very unlikely that you’ll use that knowledge. People who prioritize this type of knowledge are also prone to procrastination. They focus solely on what could happen. This keeps them in an endless cycle of worry and anxiety that prevents them from accomplishing the goals they’ve set for themselves. We prioritize just-in-time knowledge and reference Tim Ferris, who said, “Prefer just-in-time knowledge over just-in-case knowledge.” 3. Do and Reflect Getting things done while learning relevant aspects is good for our growth. Reflection gives us new perspectives of ourselves that allow us to analyze and improve on areas we are weak. It is important to see your goals through. Doing so staves off doubt, depression, and anxiety. It builds your character in the process, putting you in a position to continually improve. Resist the temptation to quit or give up. Do not second-guess yourself by wondering if you should do something else instead. Guard your mind against self-doubt and stay focused on the task at hand. Take action over your patterns, routines, and nuances. Don’t allow complacency to creep in as it can drain you of all your potential, leaving you depressed and unfulfilled. Adapt to changing circumstances and build on routines that make you better. 4. Building Confidence & Embracing the Unknown The action involves stepping into the unknown. Embracing uncertainty allows us to confront fears and doubts that hinder progress. Navigating through uncharted territories is scary and unpleasant. However, doing so builds and grows confidence. This confidence stems from realizing we can overcome challenges and learn from them. Overthinking can create worst-case scenarios that fill us with fear. Fear can hold you back from achieving your potential. Take the leap of faith into the unknown, and overcome the challenges that await you. As David Goggins says, “Embrace the suck!” It might not be pleasurable in the beginning, but you will learn how to deal with it. You’ll master how to navigate uncharted waters and come out the other side stronger than before. Conclusion Action breeds clarity and encapsulates a fundamental truth that transcends various aspects of life. It allows us to break free from the constraints of overthinking. We gain insights, experiences, and wisdom that lead to a clearer understanding of ourselves and our environment. The courage to take action propels us toward our goals while fostering adaptability and self-confidence. Action holds the key to the clarity we seek. The world is your oyster. Stop overthinking and act starting today. For these and more thoughts, guides and insights visit my blog at martinbaun.com martinbaun.com

Action Breeds Clarity

Docker in Action: Downloading Images, Building Containers, and Exposing Ports

Authors: (1) Philipp Straubinger, University of Passau, Passau, Germany and this author contributed equally to this research; (2) Tommaso Fulcini, Politecnico di Torino,  Torino, Italy and this author contributed equally to this research; (3) Gordon Fraser, University of Passau, Passau, Germany; (4) Marco Torchiano, Politecnico di Torino, Torino, Italy. Table of Links Abstract and Introduction Background and Related Work Implementation Experiment Results Conclusions, Acknowledgement, and References 6 CONCLUSIONS This paper presents the integration and empirical evaluation of IntelliGame, a gamification plugin originally designed for Java development, in the realm of JavaScript unit testing. The study aimed to validate IntelliGame’s effectiveness in JavaScript, adapting it to the popular Jest testing framework. Despite challenges such as transitioning from IntelliJ Community Edition to Ultimate for JavaScript support and addressing differences in coverage information, we successfully ported 19 out of 26 achievements. The controlled experiment with 152 participants revealed mixed perceptions of IntelliGame’s impact, with achievements influencing testing behaviour and participants’ motivation. We will continue with an in-depth analysis of the experimental measures and the code written by the participants to gain more insights and to broaden our knowledge of IntelliGame. ACKNOWLEDGEMENT This study was carried out within the “EndGame - Improving Endto-End Testing of Web and Mobile Apps through Gamification” project (2022PCCMLF) – funded by European Union – Next Generation EU within the PRIN 2022 program (D.D.104 - 02/02/2022 Ministero dell’Università e della Ricerca). This manuscript reflects only the authors’ views and opinions and the Ministry cannot be considered responsible for them. This work is also supported by the DFG under grant FR 2955/2-1, “QuestWare: Gamifying the Quest for Software Tests”. REFERENCES [1] Riccardo Coppola, Tommaso Fulcini, Luca Ardito, Marco Torchiano, and Emil Alègroth. 2023. On Effectiveness and Efficiency of Gamified Exploratory GUI Testing. IEEE Transactions on Software Engineering (2023), 1–16. https://doi.org/ 10.1109/TSE.2023.3348036 [2] Sebastian Deterding, Dan Dixon, Rilla Khaled, and Lennart Nacke. 2011. From Game Design Elements to Gamefulness: Defining "Gamification". In Proceedings of the 15th International Academic MindTrek Conference: Envisioning Future Media Environments (Tampere, Finland) (MindTrek ’11). Association for Computing Machinery, New York, NY, USA, 9–15. https://doi.org/10.1145/2181037.2181040 [3] Tommaso Fulcini, Riccardo Coppola, Luca Ardito, and Marco Torchiano. 2023. A Review on Tools, Mechanics, Benefits, and Challenges of Gamified Software Testing. ACM Comput. Surv. 55, 14s, Article 310 (jul 2023), 37 pages. https: //doi.org/10.1145/3582273 [4] Andreas Jedlitschka and Dietmar Pfahl. 2005. Reporting guidelines for controlled experiments in software engineering. In 2005 International Symposium on Empirical Software Engineering, 2005. IEEE, 10–pp. [5] José Miguel Rojas and Gordon Fraser. 2016. Code Defenders: A Mutation Testing Game. In 2016 IEEE Ninth International Conference on Software Testing, Verification and Validation Workshops (ICSTW). 162–167. https://doi.org/10.1109/ICSTW. 2016.43 [6] Statista. 2023. Most used programming languages among developers worldwide as of 2023. https://www.statista.com/statistics/793628/worldwide-developersurvey-most-used-languages/ Accessed: 2023-12-05. [7] Philipp Straubinger and Gordon Fraser. 2023. A Survey on What Developers Think About Testing. In 2023 IEEE 34th International Symposium on Software Reliability Engineering (ISSRE). 80–90. https://doi.org/10.1109/ISSRE59848.2023.00075 [8] Philipp Straubinger and Gordon Fraser. 2024. Improving Testing Behavior by Gamifying IntelliJ. In Proceedings of the 46th IEEE/ACM International Conference on Software Engineering, ICSE 2024, Lisbon, Portugal, April 14-20, 2024. ACM, 49:1–49:13. https://doi.org/10.1145/3597503.3623339 [9] Kwangwon Sun and Sukyoung Ryu. 2017. Analysis of JavaScript programs: Challenges and research trends. ACM Computing Surveys (CSUR) 50, 4 (2017), 1–34. [10] Bo Wang, Aashish Kolluri, Ivica Nikolic, Teodora Baluta, and Prateek Saxena. 2023. User-Customizable Transpilation of Scripting Languages. Proc. ACM Program. Lang. 7, OOPSLA1 (2023), 201–229. https://doi.org/10.1145/3586034 This paper is under CC BY-SA 4.0 DEED license. available on arxiv

IntelliGame in Action: Gamifying JavaScript Unit Tests - Conclusions, and References

Authors: (1) Philipp Straubinger, University of Passau, Passau, Germany and this author contributed equally to this research; (2) Tommaso Fulcini, Politecnico di Torino,  Torino, Italy and this author contributed equally to this research; (3) Gordon Fraser, University of Passau, Passau, Germany; (4) Marco Torchiano, Politecnico di Torino, Torino, Italy. Table of Links Abstract and Introduction Background and Related Work Implementation Experiment Results Conclusions, Acknowledgement, and References 5 RESULTS While the analysis of results is ongoing, we provide a preliminary overview by addressing the challenges encountered, our problem-solving approaches, and insights from the exit survey completed by students regarding their perceived user experience. 5.1 Survey Answers Based on the responses to the exit survey (Fig. 2), the chosen target class was well-received by all groups. All groups unanimously agreed that the class was easy to comprehend and implement. However, it is noteworthy that just under half of the participants in the treatment group and fewer than 40% in the control group indicated they had sufficient time to complete the implementation. Consequently, it is not surprising that only approximately 25% in both groups felt they had enough time to conduct thorough testing of their implementations. Interestingly, around two-thirds of all participants actively tested their code. Notably, a smaller percentage of participants wrote tests during the development phase, with 52% in the treatment group compared to 44% in the control group. Roughly 50% of participants in both groups were confident in the correctness of their implementations. Conversely, only 21% in the treatment group and 14% in the control group were certain about the quality of their test suites. No significant differences were observed between the two groups. Concerning the responses of the treatment group regarding IntelliGame, they are predominantly positive or, at worst, undecided (Fig. 3). Participants demonstrated a clear understanding of the tool’s descriptions and how to make progress in the presented achievements. They also appreciated the frequency of the notifications. About 40% of the participants reported that the achievements positively influenced their testing behavior, and an equivalent percentage mentioned being motivated by both the notifications and the plugin itself. Encouragingly, 42% of participants expressed a desire to use IntelliGame in their own projects. 5.2 Problems Faced and Lessons Learned In the initial adaptation phase, we faced challenges while transitioning the original TypeScript project to JavaScript. Although automatic transpilation facilitated obtaining the correct JavaScript code, the hurdle lies in converting the TS configuration to a JScompatible one. Since the original project used another testing framework, i.e., Karma, we had to modify the configuration to fit Jest. Another challenge arose when configuring the main.js file for manual function assessment. Unlike Java, where a Main class defines the starting point, JavaScript, especially in the Node framework, lacks that. So, in order to reproduce the same setting as the original validation experiment [8], we had to create a custom file for this purpose. Throughout the experiment, additional issues surfaced and required adaptation of the plugin. In the first session, participants could only choose between running the project via tests or main execution due to the provided configuration. Despite being shown how to switch between configurations, most participants stuck with one method for the entire session. Upon reflection, we observed that the number of tasks overwhelmed participants, leading them to feel demotivated despite knowing that their performance would not be evaluated. While they found the functions appropriately challenging, the abundance of tasks influenced their survey responses negatively (e.g., rating their implementation/test suite as being not good enough and expressing dissatisfaction with the tool). We attribute the superior performance of students in the pilot study to their greater experience and a less pressured environment. To address this, future experiments will involve students with comparable experience levels to the overall sample. We hypothesize that incorporating gamification elements aimed at promoting TDD approach to the plugin may yield to even more encouraging results. Minor issues included students incorrectly selecting a parent directory when opening the project, interrupting the script that committed their progress to the repository. We promptly identified and resolved these problems. General challenges with the committing process stemmed from variations in participants’ laptop configurations, which we sometimes deemed unsolvable, opting to collect the final project state at the designated time. This paper is under CC BY-SA 4.0 DEED license. available on arxiv

IntelliGame in Action: Gamifying JavaScript Unit Tests - Results

Imagining a world less economically interconnected than our current one is challenging. Yet, three decades ago, global interactions were markedly different – companies engaged in significantly fewer cross-border payments and were predominantly focused on domestic endeavors. Fast forward to today’s borderless global economy reliant on international supply chains, remote workforces, and API-first tech stacks, and the siloed business models of yesteryear have nearly completed their relegation to obsolescence. With a persistent desire to increase the speed of processes across organizations and government agendas worldwide, there is a modern imperative to streamline cross-border payments to improve efficacy. However, fraud is the primary challenge contributing friction to the objective at hand. Two Aspects to Improve: Speed & Security The surge in cross-border payments, driven by trade, capital, and migration flows, is only expected to climb – with a reported __ __With such expected growth comes a need to improve the efficiency and speed of cross-border payments, as evidenced by conversations led by the European Union in recent times. $190 trillion in 2023 projected to reach $290 trillion by 2030. In October 2022, the European Commission introduced a legislative proposal aimed at enabling citizens with bank accounts in the European Economic Area to execute instant euro payments. Earlier this month, the legislation was officially passed, with banks and payment service providers now mandated to allow EU citizens and businesses to conduct nearly instantaneous credit transfers. Despite significant growth, cross-border payments remain expensive and sluggish with fees , and a timeframe that can take up to several days for payments to complete. Reducing the cost, speeding up the process, and enhancing the accessibility of cross-border payments would yield significant advantages, particularly in emerging and developing economies. averaging 1.5% for corporations, 6.3% for remittances The critical challenge for companies engaged in this field is to devise strategies that effectively balance the two aspects of speed and security; to serve customers' ideal desires of near-instantaneous payments that are completely secure. The Cross-Border Payments Fraud Problem Unfortunately, this is easier said than done. While only representing 11% of total card payment transactions, cross-border payments accounted for . Fraudsters are particularly drawn to cross-border payments because they can easily steal funds, often as a result of weak security measures. 63% of card fraud Most notably, the physical distance between the fraudsters and their victims significantly lowers the chances of the perpetrators being caught. Since victims have limited options for recourse after being defrauded, cross-border payments are frequently seen as the easiest opportunity for fraudsters to execute scams. How Fraud Undermines Trust Increasing fraud rates have the potential to erode trust in the security of cross-border payments, and a loss of faith in the security of these payments could lead to an eventual decline, diminishing the future viability of businesses dependent on an international marketplace. Victims of cross-border payment fraud are ensnared by an array of sophisticated tactics. In Account Takeover (ATO) fraud, perpetrators gain unauthorized access to victims' banking or digital wallet accounts, manipulating them for illicit transactions. Even within the broader fraud threat landscape, account takeovers are a growing problem, with an estimated 22% of adults in the US falling victim to this type of fraud in 2022. Another popular method is chargeback fraud, which involves deceitful transaction reversals, while stolen card fraud sees the unauthorized use of credit or debit card details for fraudulent purchases or withdrawals. While sometimes referred to as ‘friendly fraud,’ chargeback fraud can be far from pleasant and is growing at a rate of around 41% a year. Cross-border payments are also susceptible to fraudsters looking to commit money laundering. Money laundering intricately disguises the origins of illicit funds, complicating efforts to trace them back to criminal activities. Once again, this is a huge fraud problem generally. In fact, anti-money laundering fines were up 50% last year alone. Other forms of fraud affecting the cross-border payment process include BIN attacks, triangulation fraud, and Authorized Push Payment (APP). Together, these tactics not only inflict financial losses but can also severely damage victims’ credit history and erode trust in digital financial transactions across the board. New Ways to Address Old Problems The answer to addressing fraud in cross-border payments is to get proactive and stop the issue before it occurs. Unfortunately, traditional risk technologies have been expensive to develop, slow to implement, complex, and ultimately, unable to keep pace with evolving fraud trends. Thankfully, new solutions are now coming to the fore that offer significant improvements. Artificial intelligence (AI) advancements have opened new avenues to address these challenges. Through advanced digital footprinting and the power of machine learning, modern fraud prevention solutions that leverage AI can find the tell-tale signs of fraud that humans tend to miss and help to stop it in its tracks. For companies like SEON, the ability to enrich data is key to this effort. Without always realizing it, users regularly leave behind digital footprints on the sites they visit. By analyzing this information, solutions like ours can unlock the likelihood of an individual being fraudulent while simultaneously making other critical determinations around online accounts. Fraud prevention solutions that leverage AI have the potential to impart considerable new trust across the cross-border payment space. Whether it’s leveraging behavioral analysis techniques to spot anomalies in user behaviors that indicate account takeovers or utilizing transaction monitoring to spot any unusual transfers of funds, the technology could be transformative. Maintaining Trust In the context of cross-border money transfers, trust is paramount. Without maintaining this trust, the entire system risks being compromised. Embracing and integrating advanced technologies is not just about safeguarding funds; it is a crucial step in ensuring the integrity and reliability of the global financial system. Thus, adopting solutions utilizing AI, machine learning, and other state-of-the-art tools, like SEON, represents more than technological progress. More than ever, it's increasingly vital for companies and individuals undertaking this essential process to recognize their role in combating the growing threat of fraud. For more information about SEON, please visit: <https://seon.io/](https://seon.io/) Also published here

Combatting Cross-Border Payment Fraud: A Call to Action for Secure Transactions

Authors: (1) Philipp Straubinger, University of Passau, Passau, Germany and this author contributed equally to this research; (2) Tommaso Fulcini, Politecnico di Torino,  Torino, Italy and this author contributed equally to this research; (3) Gordon Fraser, University of Passau, Passau, Germany; (4) Marco Torchiano, Politecnico di Torino, Torino, Italy. Table of Links Abstract and Introduction Background and Related Work Implementation Experiment Results Conclusions, Acknowledgement, and References 4 EXPERIMENT The primary aim of the experiment was to replicate the conditions outlined in the original validation paper [8], adhering to the guidelines set by Jedlitschka et al. [4]. However, as the goal was not to assess the effectiveness of the tool but rather to test its applicability with a different programming language and subjects, we introduced some modifications to the experimental approach. 4.1 Participant Selection We invited graduate students from the Software Engineering course at Politecnico di Torinoto participate voluntarily in the experiment. Successful participation earned students additional points for their Software Engineering exam, with the assurance that their performance would not impact their bonus points to avoid bias. All participating students possessed prior JavaScript testing experience, as the Software Engineering course extensively covered unit testing using the Jest framework. The sample of participants in this study comprised 152 individuals, with 85% identifying as male and the remaining 15% as female. Over 90% fell within the age range of 22 to 25, being graduate students. The participants were randomly assigned to one of two groups: treatment and control. The majority of participants had less than three months of experience with JavaScript, and it is worth noting that the treatment group had less experience compared to the control group with 59% and 47% having less than three months of experience, respectively. Additionally, 96% of participants in both groups had less than three months of experience with Jest. In fact, the majority of participants were introduced to JavaScript and Jest during the course’s lectures. 4.2 Project Selection Initially, with a shift in the reference programming language, the need arose to select an alternative project, departing from the FixedOrderComparator Java class used in the original study [8]. Our criteria for project selection involved finding a subject that presented both challenge and feasibility within a 150-minute timeframe. We sought a real existing project to capture the complexity 3https://github.com/tsantalis/RefactoringMiner of a real-world scenario, emphasizing documentation, a comprehensive test suite, and modularity. Modularity was crucial, allowing participants to choose among modules, and deciding whether to tackle more complex or simpler functions. The selection process began by exploring JavaScripting[4], a repository of publicly available JavaScript projects. Given the extensive collection, including popular frameworks like React, React Native, Vue, and Angular, we narrowed down our search to importable lightweight libraries with standardized functionalities. We focused on the miscellaneous category for a subject meeting our criteria. The first project suiting our needs was Date Fns5 , an open-source project featuring 244 functions related to the date data type. Functions ranged from trivial tasks like determining the order between two dates to more complex operations like formatting data with ISO or RFC representation. The project, widely used (over two million times) and well-maintained by 300+ contributors with over a thousand forks, met our requirements. The project, however, was developed in TypeScript (TS) rather than JS. Notwithstanding the difference between the two programming languages, given the high project usage and reliability, the full interoperability of JS code in TS and the possibility of directly transposing TS code into JS, was deemed that this language difference was not a reason for exclusion. Moreover, we consider it valuable for the reader to discuss in section 5.2 the problems encountered and the solutions put in place to resolve them. For these reasons, we used the JS version obtained through transpilation [10]. The seamless interoperability between the two languages facilitated the conversion of functions from TS to JS, made possible with the help of the open-source automatic tool transform[6]. 4.3 Experiment Task We carefully chose a set of 23 functions from the original GitHub Date Fns project, prioritizing simplicity in terms of complexity and lines of code. The aim was to ensure that most students could confidently build and test these functions without feeling overwhelmed by their difficulty Before assigning the experiment task, we conducted a pilot study with three master’s students nearing graduation. This helped validate the task’s scalability. While no data was collected from them, the pilot ensured proper calibration by adjusting the assignment’s complexity, excluding the three most challenging functions. The functions’ bodies were removed, leaving the requirements, function names, and parameters intact. The project incorporated complete JavaScript documentation for built-in date functions, eliminating the need for online references. Two verification methods were provided: a Jest configuration with empty test files for participants to complete and run, and a main.js file acting like the Main class in Java, mirroring the original experiment’s setup [8]. Two sessions were held: the first with 60 participants and the second with the remaining individuals. This division allowed potential data discarding from the first day if any issues arose. Participants were split into a control group, tackling tasks without achievements, and a treatment group, completing tasks with the plugin enabled. Participants from the treatment group were instructed on how the gamification plugin works but were not shown in detail the conditions for unlocking each achievement. These were shown in an overlay box displayed on the screen when hovering the mouse over each achievement of the list. During the experiment, a custom event logger recorded achievement states after each user interaction. An automated script committed and pushed current implementations and log files to a Git repository every minute. Following the 150-minute implementation phase, an exit questionnaire featured general questions for both groups. The treatment group received an additional page at the end of the survey inquiring about their plugin experiences, with answers on a five-point Likert scale. An optional free-text question allowed participants to share individual comments and feedback. This paper is under CC BY-SA 4.0 DEED license. available on arxiv [4] https://www.javascripting.com/ [5] https://github.com/date-fns/date-fns [6] https://github.com/ritz078/transform

IntelliGame in Action: Gamifying JavaScript Unit Tests - Experiment

Authors: (1) Philipp Straubinger, University of Passau, Passau, Germany and this author contributed equally to this research; (2) Tommaso Fulcini, Politecnico di Torino,  Torino, Italy and this author contributed equally to this research; (3) Gordon Fraser, University of Passau, Passau, Germany; (4) Marco Torchiano, Politecnico di Torino, Torino, Italy. Table of Links Abstract and Introduction Background and Related Work Implementation Experiment Results Conclusions, Acknowledgement, and References 3 IMPLEMENTATION To enable JavaScript support in IntelliGame, we transitioned from using IntelliJ Community Edition to IntelliJ Ultimate[1]. This shift was necessary because JavaScript support is exclusively available in the latter. While we managed to adapt most of the existing test achievements for JavaScript, some proved challenging to port, and a few were even deemed impossible. Adjusting for test execution tracking, such as the number of tests and assertions, was straightforward, thanks to the Jest testing framework’s syntax[2]. However, obtaining coverage information posed a greater challenge. The built-in test engine of IntelliJ lacks the same coverage details for JavaScript as it does for Java, such as covered branches or methods. To address this, we devised a specialized test execution configuration that utilizes Jest to output overall coverage information to the console. We extract and employ this information for our achievements. Additionally, Jest writes coverage details to a JSON file, offering comprehensive class-specific information that we leverage for the remaining achievements. In summary, we extract JavaScript coverage information from three sources: the built-in test engine, the console, and summary files. Another obstacle arose with the JavaScript debugger, which lacks support for method breakpoints and field watchpoints, required by the implementation of some of the achievements. Unfortunately, we could not find suitable alternatives for these features. Similarly, most of the refactoring-related achievements, implemented using RefactoringMiner for Jav[a3], lacked equivalent tools for JavaScript. Despite facing challenges, we successfully transferred 19 achievements out of 26 from Java to JavaScript. These achievements can be identified by a small JavaScript symbol (see Fig. 1). Each achievement is represented by a trophy indicating the level, a progress bar showing the current progress towards the next level, and a description detailing the progress required for reaching the next level, accessible by hovering over the question mark. For further details and explanations of the achievements, refer to related work [8]. This paper is under CC BY-SA 4.0 DEED license. available on arxiv [1] https://www.jetbrains.com/products/compare/?product=idea&product=idea-ce [2] https://jestjs.io/ [3] https://github.com/tsantalis/RefactoringMiner

IntelliGame in Action: Gamifying JavaScript Unit Tests - Implementation

Authors: (1) Philipp Straubinger, University of Passau, Passau, Germany and this author contributed equally to this research; (2) Tommaso Fulcini, Politecnico di Torino,  Torino, Italy and this author contributed equally to this research; (3) Gordon Fraser, University of Passau, Passau, Germany; (4) Marco Torchiano, Politecnico di Torino, Torino, Italy. Table of Links Abstract and Introduction Background and Related Work Implementation Experiment Results Conclusions, Acknowledgement, and References 2 BACKGROUND AND RELATED WORK Compared to writing code, testing is often viewed as less rewarding by software developers, requiring significant effort without always resulting in due recognition from management [7]. To address issues related to motivation and acknowledgment of testers’ contributions, various solutions have been proposed, encompassing both extrinsic and intrinsic motivators. Gamification, a rising trend in this domain, has experienced substantial growth over the past decade [3], even leading to dedicated conferences in the academic sector. Defined as by Deterding et al. [2], gamification involves creating a playful environment in which users can accomplish their daily tasks. Completing daily goals within such an environment allows users to benefit from the motivators associated with the designed game elements, making the underlying activity more engaging and satisfying. the use of game elements in a non-playful context Software testing has been successfully gamified in particular in the context of education. For example, Code Defenders [5] is a gamified application to teach mutation testing concepts in an academic setting, where students assume either of two roles: attackers or defenders. Users from both sides engage in a mutual challenge on a shared Java class, applying mutation testing. The attackers’ goal is to create code mutants (variants of the class with the same functionality), while the defenders’ objective is to enhance the existing test suite with new test cases to detect the code mutants. The gamified platform incorporates mechanics and dynamics that integrate social interaction, creativity, and competition. Gamification has also been applied in a practical rather than educational context. For example, Coppola et al. [1] propose a framework to gamify exploratory GUI testing using a Capture and Replay tool for web applications. The gamification layer introduces common game elements such as scores and leaderboards, as well as novel elements not previously explored in the literature, including dynamic visual bug injection with related visual feedback and scores, along with a progress bar tracking the tester’s exploration, i.e., the achieved widget coverage of a specific web page. As indicated in a recent survey on gamified software testing [3], current trends in the literature show that unit testing is the most targeted level, with the most focused testing phase being test creation and execution. Popular techniques considered by researchers and practitioners include Mutation, Black Box, and White Box testing. While IntelliGame initially emerged as a unit test tool, its achievement-based structure allows for extensibility across various testing dimensions, introducing achievements specific to each. This paper is under CC BY-SA 4.0 DEED license. available on arxiv

IntelliGame in Action: Gamifying JavaScript Unit Tests - Background and Related Work

Authors: (1) Philipp Straubinger, University of Passau, Passau, Germany and this author contributed equally to this research; (2) Tommaso Fulcini, Politecnico di Torino,  Torino, Italy and this author contributed equally to this research; (3) Gordon Fraser, University of Passau, Passau, Germany; (4) Marco Torchiano, Politecnico di Torino, Torino, Italy. Table of Links Abstract and Introduction Background and Related Work Implementation Experiment Results Conclusions, Acknowledgement, and References ABSTRACT This paper investigates the integration and assessment of IntelliGame, a gamification plugin initially designed for Java development, within the realm of JavaScript unit testing. We aim to verify the generalizability of IntelliGame to JavaScript development and to provide valuable insights into the experiment’s design. For this, we first customize IntelliGame for JavaScript, and then conduct a controlled experiment involving 152 participants utilizing the Jest testing framework, and finally examine its influence on testing behavior and the overall developer experience. The findings from this study provide valuable insights for improving JavaScript testing methodologies through the incorporation of gamification. CCS CONCEPTS • Software and its engineering → Software testing and debugging; Integrated and visual development environments. KEYWORDS Gamification, IDE, IntelliJ, Software Testing ACM Reference Format: Philipp Straubinger, Tommaso Fulcini, Gordon Fraser, and Marco Torchiano. 2024. IntelliGame in Action: An Experience Report on Gamifying JavaScript Unit Tests. In 2024 First IDE Workshop (IDE ’24), April 20, 2024, Lisbon, Portugal. ACM, New York, NY, USA, 5 pages. https://doi.org/10.1145/3643796. 3648466 1 INTRODUCTION IntelliGame [8] is a plugin for the popular IntelliJ IDEA, which enables gamification covering various aspects of software testing, such as test execution, coverage evaluation, debugging, and test refactoring. It introduces 27 different achievements, each with incremental levels, providing positive feedback when developers exhibit commendable testing behavior. IntelliGame provides real-time analysis of developer interactions, notifications, and a user interface within IntelliJ to display achievements and progress. In its original evaluation [8], we conducted a controlled experiment with 49 participants to study the impact of IntelliGame on testing behavior. The experiment involved a Java programming task with participants divided into different groups, aiming to assess the impact of the gamified environment on testing behavior, test suites, achievement levels, code functionality, and the overall developer experience. The results showed clearly that IntelliGame had a positive effect on testing behavior. Participants using IntelliGame wrote more tests, achieved higher code coverage and mutation scores, ran tests more frequently, and implemented functionality earlier compared to the control group. The impact on resulting test suites was substantial, and achievements correlated positively with various testing metrics. The goal of this paper is to build upon these promising results achieved with IntelliGame for Java environments, and to assess whether these outcomes can be replicated on a larger scale and in a different context. In particular, the extension of the positive impact of achievements in the IDE to various programming languages remains unexplored. Thus we shifted the focus of this study to JavaScript (JS), recognized as the most used language as of 2023 [6]. With the growing importance of JS, there is an increasing demand to instruct and practice language-specific testing activities. Expanding beyond the previous sample, this study engages a broader audience with multiple tasks, allowing for more extensive code development and testing. This expansion, coupled with the shift to a different programming language, considers both generalizability and effectiveness beyond a short-term context. The objective of this paper is to provide an in-depth description of the experiment’s design, including challenges encountered, lessons learned, and recommendations for future iterations of JSbased experiments. Notably, there is a gap in the existing literature regarding programming experiments centered on an open-source JavaScript target [9], emphasizing a fully replicable and systematic approach. In Section 2 we provide some background about the topic of the paper with also some examples of related works, inSection 3 the implementation approach for the JavaScript version of IntelliGame is described, while Section 4 shows the selection process for the project as a subject is meticulously detailed, shedding light on the rationale behind the choice. This paper is under CC BY-SA 4.0 DEED license. available on arxiv

IntelliGame in Action: Gamifying JavaScript Unit Tests - Abstract and Intro

Recently while trying to integrate a devsecops tool in my pipeline, i was trying to find the GitHub action which would simplify my workflow. Since i could not find it, i have to write the commands inline to run the command. Although it is not a hassle to write it within the script, it would be beneficial to have an action which we could directly call, pass parameters and run the action within the pipeline. In this blog, i will walk you through different steps on how you can create a custom GitHub actions which would satisfy your requirement. The blog will be of 2 parts: Understanding what the GitHub action are Creating your custom GitHub actions GitHub actions: Often when we write pipelines, we would have a set of actions which we would like to perform based on the type of application that we are developing. In order for us to run these actions across the repos in our organization, we would have to copy + paste this code across the repositories, which would make this process error prone and maintenance tussle. It would be better if we take DRY principle of software engineering and apply it to CI/CD world. GitHub action is exactly this principle in practice. We create and host the required action in a certain GitHub public repository and this action is used across the pipeline to perform the action defined in the action. Now that we understand what GitHub action is, lets explore how we can build a custom GitHub action which can help automate set of actions. For this blog, i illustrate it with an example of SBOM enrichment tool Parlay, for which i have built a custom action. Creating Custom Action - A case on Parlay We will be creating our custom action in the following steps: Defining inputs and outputs in action.yml Developing business logic in bash script Dockerize the bash application Test the action Publish it in GitHub action Marketplace Defining inputs and outputs in action.yml To start creating custom action create a custom git repository, clone that repo in your local system and open it up in your favourite code editor. We start by creation a file named actions.yml. This actions.yml defines the inputs that the action would take, the outputs that it would give and the environment it will run. For our use case we have 3 inputs and 1 output. The actions.yml should have following arguments: name: This would be the name of the action, which would be used to search in GitHub action marketplace. Since it would be published in marketplace, it’s name should be globally unique like s3 bucket. description: This describes what your action would do. This would be helpful to identify which action would be the right fit for our use case. inputs: Defines the list of options which would be used within the action. These can be compulsory or optional, which can be defined using “required” argument. In our current use case we are passing 3 arguments, input_file_name, enricher and output_file_name. outputs: This enlists the list of outputs that the action gives. runs: defines the environment in which action will execute , which in our case is docker The action.yml will look something like this: action.yaml

name: "Parlay Github Action"
description: "Runs Parlay on the given input file using the given enricher and outputs it in your given output file"
branding:
icon: "shield"
color: "gray-dark"
inputs:
input_file_name:
description: "Name of the input SBOM file to enrich"
required: true
enricher:
description: "The enricher used to enrich the parlay sbom. Currently parlay supports ecosystems, snyk, scorecard(openssf scorecard)"
required: true
default: ecosystems
output_file_name:
description: "Name of the output file to save the SBOM enriched using the parlay's enricher"
required: true
outputs:
output_file_name:
description: "Prints the output file"
runs:
using: "docker"
image: "Dockerfile"
args:
- ${{ inputs.input_file_name }}
- ${{ inputs.enricher }}
- ${{ inputs.output_file_name }} Developing business logic in bash script Once we have defined the inputs, outputs and environment that we are going to use, we would like to define what we are going to do with those inputs ( basically our logic) in a file. We can either define this in JavaScript or bash. For my current use case, i am using bash. In my current logic, i am going to check if all the inputs are first given, if not the action fails. Once i have these 3 arguments, i am going to construct the command to run the action and save the output in an output file. This file is printed in stdout and formatted using jq utility. #!/bin/bash

Check if all three arguments are provided

if [ "$#" -ne 3 ]; then
echo "Usage: $0 <input> <input_file_name> <output_file_name>"
exit 1
fi

Extract arguments

INPUT_INPUT_FILE_NAME=$1
INPUT_ENRICHER=$2
INPUT_OUTPUT_FILE_NAME=$3

Construct command

full_command="parlay $INPUT_ENRICHER enrich $INPUT_INPUT_FILE_NAME > $INPUT_OUTPUT_FILE_NAME"
eval "$full_command"

Check if the command was successful

if [ $? -eq 0 ]; then
echo "Command executed successfully: $full_command"
cat $INPUT_OUTPUT_FILE_NAME | jq .
else
echo "Error executing command: $full_command"
fi Dockerize the bash application Once we have the bash script ready, we will be dockerizing it using the following script. Whenever we invoke the action, this action which is defined in the bash script runs in an isolated docker container. In addition to the bash script in entrypoint.sh, we would also be adding the the required libraries such as wget, jq and installing parlay binary. Base image

FROM --platform=linux/amd64 alpine:latest

installes required packages for our script

RUN apk add --no-cache bash wget jq

Install parlay

RUN wget https://github.com/snyk/parlay/releases/download/v0.1.4/parlay_Linux_x86_64.tar.gz
RUN tar -xvf parlay_Linux_x86_64.tar.gz

RUN mv parlay /usr/bin/parlay

RUN ls /usr/bin | grep parlay
RUN parlay

Copies your code file  repository to the filesystem

COPY . .

change permission to execute the script and

RUN chmod +x /entrypoint.sh

file to execute when the docker container starts up

ENTRYPOINT ["/entrypoint.sh"] Test the action No amount of software is good without running some tests on it. To test the action, lets first push the code to GitHub. Once pushed, lets define the pipeline in pipeline.yaml file in .github/workflows folder. For the sake of input file, i am using a sample sbom in cyclonedx format and have pushed it to GitHub. In my pipeline.yaml file, i am cloning the GitHub repo and using my action called krishnaduttPanchagnula/parlayaction@main on cyclonedx.json. file on: [push]

jobs:
custom_test:
runs-on: ubuntu-latest
name: We test it locally with act
steps:
- name: Checkout git branch
uses: actions/checkout@v1

  - name: Run Parlay locally and get result
    uses: krishnaduttPanchagnula/parlayaction@main
    id: parlay
    with:
      input_file_name: ./cyclonedx.json
      enricher: ecosystems
      output_file_name: enriched_cyclonedx.json Once the pipeline runs, this should give output in the std-out in pipeline console as follows. Publish it in GitHub action Marketplace Once we have tested the action and that is running fine, we are going to publish it GitHub actions market place. TO do so, our custom app should have globally unique name. To make it more unique we can add icon with our custom to uniquely identify the action in marketplace. symbol and colour Once that is done you would see the button, “Draft a Release”. Ensure that your action.yml file has Name, description, Icon and color. Once you have tick marks, you would be guided to release page where you can mention the title and version of the release. After that, click on “publish release” and you should be able to see your action in GitHub Actions marketplace. Like my content? Feel free to reach out to my for interesting content and productive discussions. LinkedIn

Building & Publishing Your Own Custom GitHub Action in Marketplace

This paper is available on arxiv under CC 4.0 license. Authors: (1) Mattia Atzeni, EPFL, Switzerland and mattia.atzeni@outlook.it; (2) Mrinmaya Sachan, ETH Zurich, Switzerland; (3) Andreas Loukas, Prescient Design, Switzerland. Table of Links Abstract & Introduction Formalizing the Group-Action Learning Problem Attention Masks for Core Geometry Priors The LATFORMER Architecture Experiments Related Work Conclusion & References A. Additional Details on the Model B. Additional Experiments and Details on the Experimental Setup C. Limitations and Future Work D. Deferred Proofs Formalizing the Group-Action Learning Problem To build intuition on the kind of basic priors that we aim to infuse in neural networks, Figure 1 shows a task borrowed from ARC (Chollet, 2019). The task entails learning to fill out the yellow patches in the leftmost image (input) so that the resulting image satisfies a 90◦ rotation symmetry. The learner is given only a small set of input-output pairs: the ARC tasks have 3.3 training examples on average. Though the task is challenging for a general neural network (due to the small number of examples), it becomes easier under the prior knowledge of discrete two-dimensional point groups, one of which is the cyclic group of 4-fold rotations C4. Under this prior, it can be solved by the composition of a group action (rotating each image x by some g ∈ C4) and a shallow neural network with a non-linear activation (mapping yellow to zero and taking a pixel-wise max). More formally, we are interested in helping neural networks learn lattice transformations in a sample efficient manner by infusing knowledge priors in the model. Motivated by ARC, we focus on learning geometric transformations that belong to the symmetry group of a lattice. This pertains to the more general problem of learning group actions given the input and the output of the transformation (group-action learning). Concretely, we consider input-output transformations involving a group element g taken from some known group G that can be expressed under the general formulation: Intuitively speaking, whereas in group-action learning one aims to learn functions that involve specific (and datadependent) transformations of our data by actions of the group, in in/equivariant learning the goal is to build models that are oblivious to such actions in a systematic manner.

The Abstraction and Reasoning Corpus: Formalizing the Group-Action Learning Problem

Do you ever find yourself whispering these excuses to yourself? "When I finally get this promotion, THEN I'll have time to start my side hustle." "When the kids are a little older, THEN I'll finally get back to painting." "When I have a bigger house, THEN I can start hosting those dinner parties I've dreamed of." "When I have more money saved, THEN I'll feel secure enough to travel." If you do, you're not alone. I've been there too.  We all get stuck in the trap of thinking the perfect conditions will appear like magic down the road. Only then, the stars aligning, will we somehow be ready to chase our dreams/do the thing. But here's the spoiler no one likes to admit: That perfect "X" moment will NEVER arrive. There will ALWAYS be something—a new project at work, a sick kid, an unexpected car repair—demanding your attention and energy. "Someday" is the biggest lie we tell ourselves. It's a fluffy pillow to soften the blow of our inaction.  We wrap ourselves in its comforting excuse, but deep down, we know that if we don't make a move , "someday" will fade into "never."  Worse, it'll fade into a nagging regret you carry with you for years to come. now The Truth About Readiness (And Why it's Not What You Think) Here comes the hard-to-swallow truth: Readiness, in the way we typically picture it, is a complete myth. You don't magically become infused with expertise, bulletproof confidence, and infinite resources after some external factor changes. Think about it this way: Did Beyoncé wake up one day feeling flawlessly ready to conquer the world, or did she build her skills, stage presence, and business savvy through countless hours of sweat and imperfect performances? Remember that kid in your high school class who seemed effortlessly good at everything? The one who aced tests without studying and charmed even the grouchiest teachers?  I bet if you dug deeper, you'd learn they were putting in work behind the scenes when no one was looking. Readiness isn't bestowed;  it's BUILT. Each imperfect step you take forges that readiness in the fire of action. The "Start Now" Mentality: A Personal Story Years ago, I desperately wanted to leave my corporate job and become a writer (start a newsletter… blog… anything).  But "someday" was my best friend. Someday, I'd have the perfect freelance client roster. Someday, I'd finally figure out this whole online marketing thing. Someday... Paralysis set in. All I did was watch videos, buy fancy courses, and dream.  One day, in a moment of frustration with myself, I decided to try something new. I forced myself to write a single blog post and hit publish...even though I thought it was terrible. YouTube The next day, I did it again. And again. Some were cringe-worthy, and some gained a bit of traction. But it didn't matter.  The act of doing, however messy, was chipping away at my fear and building my skills.  Within a year, I had enough momentum and income to make the leap into earning some income, selling ads on a newsletter (fast forward to today, the newsletter has 320,000 subscribers). That never happens if I keep waiting for the magic moment of readiness. Messy Action > Perfect Inaction Let's make this real. Let's say your dream is to get in shape finally. Here's the old mindset vs. the action-first mindset: Old "Someday" Mindset: I need to join the fancy gym. I need the perfect workout clothes. I need to find a trainer and get a program designed... Result:  You end up spending weeks comparing gym memberships and end up doing  nothing. Action-First Mindset: It's rainy out, and I'm tired, but my old sneakers are fine. I'll do one of those YouTube workout videos in my living room. It might be awkward, but I'm gonna get moving. Result: It's not glamorous, but it's a start! You're BUILDING the habit of moving your body regularly. Each day it gets a tiny bit easier. "But What About..." (Common Barriers Busted) I can hear the objections whispering in your head. So let's tackle some of the most common ones: Truth bomb: We ALL have the same 24 hours. Successful people aren't gifted extra time; they get ruthless about priorities.  Audit your day. Where does your time vanish on social media, mindless TV, or tasks that could be outsourced? Can you carve out even 15 minutes a day for your goal? You'll be shocked at what you can do with focused intention. "I don't have TIME!" Aren't you more afraid of never trying and living with regret? Failure is inevitable on the path to anything worthwhile. Embrace it as a teacher. Each stumble informs what to do differently –  that's growth happening. "I'm afraid of FAILING!" This is where creativity is your superpower. Can't afford a class? There's an insane amount of free knowledge online. Need equipment?  Look for secondhand options or see if a friend will loan it.  Remember, it's about your resourcefulness, not the size of your wallet. "I don't have the RESOURCES!" The Bottom Line: "Someday" Will Betray You Every day spent waiting for perfect conditions is a day you're not actively building the life you truly want. Imagine yourself five years from now. Do you want to look back and see a trail of "somedays" fading into the distance? Or do you want to see how far you've come because of those imperfect first steps you finally took? The "Start Now" Challenge (Take it Seriously!) I want to challenge you, and I mean challenge you, to take one small, uncomfortable step toward your goal today.  Not tomorrow, not after you research/plan/organize more – TODAY. Don't let yourself off the hook! really Here's how: What's the absolute smallest action that you've been avoiding? (Ex: write 50 words, send a sales email, register for that one class, do 10 pushups) The Tiny Task: Don't overcomplicate it. Clear your space, set a timer for 20 minutes, do whatever gets that task in front of you. Remove the Barriers: Don't judge the quality, just focus on getting it DONE. Prove to yourself you can follow through. DO IT (no matter how imperfectly): You Are Readier Than You Think You wouldn't be reading this if there wasn't a fire inside of you, a voice whispering that you're meant for more.  Don't betray that part of yourself. Take the leap today, even just a tiny one. One step leads to another and then another, and suddenly that "someday" dream is within your grasp. The choice is yours. Are you ready to ditch the excuses and finally start building a life filled with purpose and passion? Then it's time to stop waiting on "X" and create your readiness. Your future self will thank you. Have a great week! Scott Also published . here

Choosing Messy Action Over Perfect Inaction

This paper is available on arxiv under CC 4.0 license. Authors: (1) Vogt, Lars, TIB Leibniz Information Centre for Science and Technology; (2) Konrad, Marcel, TIB Leibniz Information Centre for Science and Technology; (3) Prinz, Manuel, TIB Leibniz Information Centre for Science and Technology. Table of Links Abstract & Introduction Interoperability Semantic interoperability and what natural languages like English can teach us Requirements for successfully communicating terms and statements Parallels between the structure of natural language statements and data schemata with implications for semantic interoperability What makes a term a good term and a schema a good schema? The need for a machine-actionable Rosetta Stone for (meta)data that acts as an interlingua for specifying reference terms and reference schemata to support cognitive and semantic interoperability Rosetta Stone and machine-readability: UPRIs, XML Schema datatypes, and RDF for communicating terms, datatypes, and statements Rosetta Stone and machine-interpretability: Wikidata and a modeling paradigm for (meta)data statements based on English Rosetta Stone and semantic interoperability: Specifying term mappings and schema crosswalks Rosetta Stone and cognitive interoperability: Specifying display templates and using a query builder Discussion Related work Conclusion, Acknowledgements, & References The need for a machine-actionable Rosetta Stone for (meta)data that acts as an interlingua for specifying reference terms and reference schemata to support cognitive and semantic interoperability Above, we discussed the role of terms and statement structures (i.e., syntax trees and (meta)data schemata) in reliably communicating the meaning and thus the semantic content of (meta)data statements. Statement structures specify syntactic positions or slots with semantic roles or constraint specifications for a given statement type. To achieve semantic interoperability, we therefore need controlled vocabularies (i.e., ) and across ontologies for FAIR terms and their . And we need a schemata and and ontologies ontological and referential term mappings terminological interoperability (meta)dat ontological and referential schema crosswalks for FAIR (meta)data statements their schematic interoperability. We also discussed why we think that it is impossible to agree on a best term for every possible type of entity and a best schema for every possible type of statement, due to varying frames of reference and operational priorities. Therefore, we think that we need something like a to support the establishment of semantic interoperability across different terms and different schemata for a given type of (meta)data statement. This Rosetta Stone needs to function like an , with which term mappings and schema crosswalks can be easily specified and operationalized. The building blocks of the are and Each entity type must have specified a corresponding reference term, and each statement type must have a corresponding reference schema. Terms from controlled vocabularies can be mapped to their corresponding reference term, and schemata to their corresponding reference schema. Constraint specifications for slots of reference schemata must refer to reference terms in the case of resources, and to reference datatype specifications in the case of values. These three types of building blocks take over the role of , so that it would no longer be necessary to specify schema crosswalks for every possible pair of schemata of a given type of (meta)data statement and to specify term mappings for every possible pair of terms. This would minimize the number of schema crosswalks and term mappings that need to be specified in order to achieve schematic and terminological interoperability for a given type of statement (Fig. 4). machine-actionable Rosetta Stone interlingua interlingua reference terms, reference datatype specifications, reference schemata. mediating connectors Ideally, a reference schema is based on a generic Rosetta modeling paradigm that allows the reconstruction of the natural language statement underlying the datum. At the same time, it should document this statement using a formalized structure to ensure its human- and machine-actionability. With respect to human-actionability, the Rosetta modeling paradigm should reflect as closely as possible the structure of natural language statements, favoring lean over complex models, with the aim of reducing overall modeling complexity and modeling burden. Many schemata are very complex and include positions with resources that do not directly align with any input slot (e.g., and in Fig. 2E). Such schemata are not suitable for use as reference schemata. ‘scalar measurement datum’ ‘scalar value specification’ Schemata that conform to the Rosetta modeling paradigm should be easy to understand and to apply, allowing any producer of (meta)data to specify new reference schemata for types of statements that do not yet have a reference schema assigned to them, and allowing any application developer to readily use their (meta)data. It should not require experience in semantics and knowledge engineering on the part of the data producer and the application developer. With regard to the structure of reference schemata, we need to consider the machine-actionability of the resulting (meta)data statements. In other words, we need to consider which operations are important for such a reference schema. While reasoning is important for domain knowledge, especially when developing ontologies, other types of operations such as searching and exploring are more important in the context of empirical (meta)data and (meta)data management in general. However, regardless of the choice of operations and associated tools, the application of reference schemata must result in FAIR (meta)data that are machine-readable and machine-interpretable in order to be machine-actionable. As for reference terms, they should ideally be collected in a large, controlled cross-domain vocabulary and should be machine-readable and machine-interpretable to be machine-actionable.

The Need for a Machine-actionable Rosetta Stone for (meta)data That Acts as an Interlingua

Before you pay for something you've never tried, do you look at reviews? If so, you're far from alone. In fact, the average person reads at least of a new product before they commit to a purchase. 10 reviews It doesn't matter if we are talking about restaurants, movies, or online stores; reviews are essential. People want to see what kind of experiences others are having, and this has a direct impact on what they choose to do next. This concept, called social proof, has been around for a long time. It essentially states that people are more likely to take a specific action if they see others doing the same thing. In marketing, it's a powerful tool that you can use to turn skeptical visitors into new customers and build brand loyalty. Customer reviews are the ultimate form of social proof because they signal to others the quality of your product and overall brand. If you build up plenty of feedback from happy customers, you can expect to see a surge in conversions, engagement, and sales. But getting more reviews is often easier said than done. Today, I'm going to share 7 actionable tips you can use to convince customers to tell others about their experience with your business. Optimize Your Public Profiles The first thing you should do is claim and optimize profiles on sites like Yelp, Google My Business, Facebook, TrustPilot, and anywhere else customers may search for or discover your business. These are all places people will look for reviews before committing to a purchase. If someone is thinking about buying from your site but can't find a public profile on any of these sites, there's a good chance they'll keep their debit card in their wallet. At the same time, you want existing customers to find your profiles easily so they can share their experiences with others. It's also worth mentioning that when deciding how to rank sites. A business with 500+ reviews is far more likely to get the top spot over a company with a half-complete profile and less than 10 reviews. Google uses reviews You should also add widgets from reputable places like TrustPilot so new visitors can see how you rank without leaving your website. Send Post-Purchase Emails One of the best ways to get more customer reviews is to send . The mistake many marketers make is they send this email too soon after the purchase. If the person doesn't have enough experience with your product, they probably won't leave a review and will forget about your email. post-purchase emails The length of time you wait to send a post-purchase email will vary slightly based on what you're selling. A coffee company might wait a week after delivery since that's enough time for the customer to try their new drink. Meanwhile, a software company may wait two weeks or more since it takes time for customers to get familiar with their tool and make it a part of their routine. Regardless of your industry, make sure to send a follow-up email where you ask new customers to tell others what they think of your product or service. This seemingly simple request can lead to a ton of new reviews. Use In-App Push Alerts If you have , in-app push alerts are a great way to nudge customers and ask them to leave a review. On average, push notifications have an open rate of , which is a very good engagement rate when compared to other marketing strategies. an application 20% The key is to time these alerts strategically after they've used your app for the first time or completed an important action. Here are some times you should consider asking: After a customer makes a purchase After they install your app After releasing a new update If the user doesn't respond to your first request, consider sending a follow-up a week or so later. This will ensure they see your message and can act as a friendly reminder if they meant to leave a review but forgot. Ask After a Support Call When you provide great customer service, your clients will likely be in a good mood and more open to helping you out with a review. You could say something like: "I'm glad I could provide helpful service today. Reviews from customers like you help us grow and improve. Would you mind taking a few moments to leave a review today?" Most people will be happy to oblige, especially if you deliver top-notch support. You can even send a follow-up email with links to make the process super easy. Spend More Time on Social Media Believe it or not, the people spend around on social media sites every day. When you also consider that there are social media users, it shouldn't come as a surprise that social media is a goldmine for collecting customer reviews. 2 hours and 29 minutes 4.95 billion There are plenty of great ways to use social sites to get feedback from your audience. You could start by simply using a social listening tool to see if anyone is talking about your business. If you find a glowing review, don't hesitate to thank and share the review on your page. Then, you can ask the user if you can share their review on your site. Over time, you can use this strategy to find reviews on specific products and your brand as a whole. You can also get user-generated content by hosting video or . Ask customers to share themselves using your product or share something they created with your help. This strategy will help build social proof and score you some visual reviews. photo contests Offer an Incentive You can improve your response rate across all of these different strategies by offering your customer an incentive to share their thoughts. For example, you could give them 25% off their next order, a free gift, or an exclusive that they can't get anywhere else. lead magnet People are more likely to take action if they are rewarded for leaving reviews. It's worth mentioning that only people who were happy with their order will generally leave reviews for an incentive. It wouldn't make sense for someone who didn't like your product to share their thoughts for a discount on their next purchase. Respond to Reviews Responding to reviews, whether positive or negative, shows your customers you care about their feedback. We found that over of people expect businesses to respond to their reviews in 1 business day or less. To our surprise, a vast majority of brands don't respond to reviews at all. 55% This means people feel like no one is listening to them, which means they're less likely to become repeat customers. On the other hand, simply saying thank you on a positive review shows that you're listening and want to create the best experience possible. Responding to negative reviews publicly is even more important because everyone can see that you go out of your way to help resolve your customers' issues. People will feel more confident shopping on your site – and thus, are more likely to leave reviews – if you proactively respond to people who go out of their way to review your business. Final Thoughts There you have it! The 7 strategies outlined today have helped us get more reviews over the last several years. I'm confident that you can do the same, regardless of whether you're a startup or an established business. The key to making this all work is to keep things as simple as possible for your customers. Do everything you can to streamline the review process on your website, through email, and social media. People are far more likely to tell you what they think if there's little to no friction. My last piece of advice is to stay patient. If you don't see reviews flowing in overnight, don't get discouraged. It takes time, energy, and effort to build a loyal audience that's more than happy to share their thoughts, but the payoff is worth it.

7 Actionable Tips to Get More Customer Reviews

Right after my first try of Kamal (MRSK) in the spring of 2023, I understood that an ideal use case would be running it as a GitHub Action. Almost a year passed, and my 30-line action has grown and become full-featured, configurable, and reusable. In this post, I will share the evolution of the action and the lessons learned. Before we start, let me remind you what Kamal is. Kamal is a library created by 37signals to orchestrate the deployment of Docker containers. Before switching to Kamal, I had a bunch of scripts and technologies to deploy my applications. Kamal allowed me to simplify the deployment process and make it more reliable. Also, there were already some GitHub workflows for running lints and tests. Ruby In this article, I will focus on deployment. Content Overview First try Action’s File Structure Pre Build Action Build & Deploy Action Workflow Definitions Conclusion First Try In an older article about Kamal, I posted the first version of the . It was a simple action that used the action to install Ruby, then to configure the SSH agent, prepared AWS credentials and then run the and command. GitHub Action ruby/setup-ruby webfactory/ssh-agent kamal envify kamal deploy The code is below. name: Kamal

on:
  push:
    branches:
      - main

jobs:
  spec:
    uses: ./.github/workflows/specs.yml
  lint:
    uses: ./.github/workflows/lint_code.yml

  build_and_deploy:
    needs: [spec, lint]
    runs-on: ubuntu-latest
    timeout-minutes: 20
    outputs:
      image: ${{ steps.build.outputs.image }}
    env:
      RAILS_ENV: production
    steps:
      - uses: actions/checkout@v3
        with:
          ref: ${{ github.event.workflow_run.head_branch }}

      - uses: webfactory/ssh-agent@v0.7.0
        with:
          ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }}

      - uses: ruby/setup-ruby@v1
        env:
          BUNDLE_GEMFILE: ./kamal/Gemfile
        with:
          ruby-version: 3.2.2
          bundler-cache: true

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2
        with:
          driver-opts: image=moby/buildkit:master

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v1
        with:
          aws-access-key-id    : ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region           : us-east-1
          mask-aws-account-id  : 'true'

      - name: Login to Amazon ECR
        id  : login-ecr
        uses: aws-actions/amazon-ecr-login@v1

      - name: Kamal Envify
        id  : kamal-envify
        env :
          KAMAL_REGISTRY_PASSWORD: ${{ steps.login-ecr.outputs.docker_password_YOUR_AWS_ACCOUNT_ID_dkr_ecr_YOUR_AWS_REGION_amazonaws_com }}
          DATABASE_URL: ${{ secrets.DATABASE_URL }}
          REDIS_URL: ${{ secrets.REDIS_URL }}
          RAILS_MASTER_KEY: ${{ secrets.RAILS_MASTER_KEY }}
          DOCKER_BUILDKIT: 1
          BUNDLE_GEMFILE: ./kamal/Gemfile
        run: |
          ./bin/kamal envify

      - name: Kamal Deploy
        id: kamal-deploy
        run: |
          ./bin/kamal deploy There are several things to pay attention to. First, at lines , I set up the  SSH agent to be able to connect to the instances and run Docker commands. The SSH private key is stored in the GitHub secrets, which is a convenient way to store sensitive data. 27-29 On lines I set up Docker Buildx, and it was very important to download Buildkit from the repository branch. At the moment of spring-winter of 2023, Buildkit didn’t support cache manifests for AWS ECR, and I had to use the branch to get the feature ( ). 38-41, master master Issue #876 On lines , I configured AWS credentials and logged in to Amazon ECR. It is not the most secure way to login to AWS, but was the easiest way to do it at that time. 43-53 This setup had several drawbacks. The first and the most important, the action was not reusable. To configure deployment to another environment, I had to copy-paste the action completely. Besides that, the action didn’t provide the ability to run deploy without running specs and lints. It was not a big deal, but sometimes I wanted to run deploy separately. The action didn’t provide the ability to run deploy to another branch. Sometimes I wanted to restart the Traefik container. This could be done from the local machine, but for me, it would be better to do it from the action. Action’s File Structure We incrementally improved the action, added new features, and made it more configurable. Finally, we come to the set of actions that can be used in almost any project. For a better understanding of the changes, let’s look at the directory structure of the actions first. .github/
├─ workflows/
   ├─ build_deploy/
      ├─ action.yaml
   ├─ pre-build/
      ├─ action.yaml
   ├─ 01.build_deploy_production.yaml
   ├─ 02.build_deploy_staging.yaml
   ├─ 03.database_backup.yaml
   ├─ 04.build_deploy_manually.yaml
   ├─ 05.validate_pull_request.yaml
   ├─ 06.kamal_run_command.yaml
   ├─ _lint.yaml
   ├─ _specs.yaml You may notice two directories, and , both have file inside. These are that include all the necessary steps to build and deploy the application. Also, some workflows are named with a leading underscore. These are reusable workflows that consist of several jobs and steps. build_deploy pre-deploy action.yaml composite actions How are Composite Actions different from Reusable Workflows? Composite Actions allow you to bundle multiple existing workflow steps into a single action. A Composite Action cannot be used without a repo checkout while Reusable Workflows can be used without a checkout. A Reusable Workflow can include multiple jobs and multiple steps within those jobs. However, Composite Actions can only have one job. Reusable Workflow can use Secrets by declaring them to a workflow via parameters while Composite Actions cannot use Secrets in a flexible way. Files with numeric prefixes are main workflow definitions that call the reusable workflows and composite actions. They cover the most common usecases for a modern Rails project: deploy to production and staging, database backup, manual deploy, pull request validation, and Kamal command execution. Pre Build Action Let’s start with the action. It is a composite action that includes all the necessary steps to prepare the environment for the build and deploy action. pre-build The file is below. # pre-build/action.yml

name: Pre-Build

inputs:
  database-url:
    type: string
  redis-url:
    type: string
  rails-master-key:
    type: string
  aws_role_access:
    type: string
  ssh_private_key:
    type: string
  environment:
    type: string

runs:
  using: composite
  steps:
    - uses: webfactory/ssh-agent@v0.8.0
      with:
        ssh-private-key: ${{ inputs.ssh-private-key }}

    - uses: ruby/setup-ruby@v1
      env:
        BUNDLE_GEMFILE: ./Gemfile
      with:
        ruby-version: .ruby-version
        bundler-cache: true

    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v3

    - name: aws-cred-configure
      uses: aws-actions/configure-aws-credentials@v4
      with:
        role-to-assume   : ${{ inputs.aws-role-access }}
        role-session-name: samplerolesession
        aws-region       : es-east-1
        mask-aws-account-id: 'true'

    - name: login-to-aws-ecr
      id: login-ecr
      uses: aws-actions/amazon-ecr-login@v2
      with:
        mask-password: 'true'

    - name: Kamal Envify
      shell: bash
      id  : kamal-envify
      env :
        KAMAL_REGISTRY_PASSWORD: ${{ steps.login-ecr.outputs.docker_password_AWS_ACCOUNT_ID_dkr_ecr_eu_west_2_amazonaws_com }}
        DATABASE_URL: ${{ inputs.database-url }}
        REDIS_URL: ${{ inputs.redis-url }}
        RAILS_MASTER_KEY: ${{ inputs.rails-master-key }}
        DOCKER_BUILDKIT: 1
      run: |
        ./bin/kamal envify --destination=${{ inputs.environment }} Let’s walk line by line through the file. Lines describe the inputs of the action and are not interesting to us. The first step is to set up an SSH agent, and it is the same as in the first version of the action. However, as you may see, it uses from the action inputs, which allows us to use the action in different environments. After that, I setup Ruby, and it is also the same as in the first version of the action. 5-17 ssh-private-key The Docker Buildx setup step differs from the initial workflow definition. It has been updated to version 3 and now out the box, so we don’t need to define anymore. supports AWS ECR image cache driver-opts The next step is to configure AWS credentials. It is completely different from what I initially had. Instead of and authentication, I switched to the UIDC role-based authentication, which is more secure and GitHub . If you need a more detailed explanation of how to configure OpenID Connect in AWS, I suggest you read this . After the authentication is done, I login to Amazon ECR on lines . access-key-id secret-access-key advises to use it excellent guide 44-48 The final step is to run , which prepares environment variables for the deployment. The command is the same as in the first version of the action, but I added the flag to the command, which allows me to deploy to different environments. kamal-envify --destination Build & Deploy Action The next composite action is defined in folder and it is relatively simple. build_deploy # build-deploy/action.yml
name: Build & Deploy

inputs:
  environment:
    type: string

runs:
  using: composite
  steps:
    - name: Kamal Deploy
      shell: bash
      id: kamal-deploy
      run: |
        ./bin/kamal deploy --destination=${{ inputs.environment }}

    - name: Kamal Release
      shell: bash
      if: ${{ cancelled() }}
      run: |
        ./bin/kamal lock release --destination=${{ inputs.environment }} Since all preparations are done in , when this action starts, I am ready to run the command with the selected environment. pre-build kamal deploy Kamal creates a lock file before starting the build and deployment process. Usually, lock is released when deployment is finished, but if the deployment is canceled, the lock is not released. And the next workflow run will fail. To avoid this, I added the command to the action. Later this article, we will use this small hack to handle concurrent deployments correctly. kamal lock release Workflow Definitions The main workflow definitions are very simple. They just call the composite action together with reusable workflows and pass the necessary parameters. Below is an example of the file. 01.build_deploy_production.yaml # 01.build_deploy_production.yaml
name: 01. Build & Deploy Production

permissions:
  id-token: write
  contents: read

on:
  release:
    types: [published]

jobs:
  spec:
    uses: ./.github/workflows/_specs.yaml
    secrets: inherit

  lint:
    uses: ./.github/workflows/_lint_code.yaml
    secrets: inherit

  build_and_deploy:
    name: build-deploy-production
    concurrency:
      group: production_environment
      cancel-in-progress: true
    environment:
      name: production
      url: https://onetribe.team
    needs:
      - spec
      - lint
    runs-on: ubuntu-latest
    timeout-minutes: 20
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.workflow_run.head_branch }}

      - name: Pre Build
        uses: ./.github/workflows/pre-build
        with:
          database-url: ${{ secrets.DATABASE_URL_PRODUCTION_ADMIN }}
          redis-url: ${{ secrets.REDIS_URL_PRODUCTION_ADMIN }}
          rails-master-key: ${{ secrets.RAILS_MASTER_KEY }}
          aws-role-access: ${{ secrets.AWS_ROLE_ACCESS }}
          ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }}
          environment: production

      - name: Build & Deploy
        uses: ./.github/workflows/build-deploy
        with:
          environment: production The section in lines deserves attention in the file. It allows me to run only one deployment at a time. GitHub has a great that covers all possible use cases. If a deployment is already running, it will be canceled, and the step from the previous workflow run will be executed. This is an essential feature because it allows me to avoid concurrent deployments and handle them correctly. concurrency 23-25 documentation section "Kamal Release" Staging deploy is defined in the file and is similar to production, except for the event that starts the workflow: for staging deploy I use the event to GIT branch, instead of the . 02.build_deploy_staging.yaml push staging release # 02.build_deploy_staging.yaml
name: 02. Build Staging

permissions:
  id-token: write
  contents: read

on:
  push:
    branches:
      - staging

# ... In this article, I will not cover database backup workflow, as defined in the file, because it is not related to the theme of the article. However, let’s look at , , and files. 03.database_backup.yaml 04.deploy_manually.yaml 05.validate_pull_request.yaml 06.kamal_run_command.yaml The file is below. 04.build_deploy_manually.yaml # 04.build_deploy_manually.yaml
name: 04. Deploy Manually

permissions:
  id-token: write
  contents: read

on:
  workflow_dispatch:
    inputs:
      environment:
        description: 'Environment'
        required: true
        default: 'staging'
        type: choice
        options:
          - production
          - staging

jobs:
  build-production:
    name: deploy-production
    concurrency:
      group: production_environment
      cancel-in-progress: true
    environment:
      name: production
      url: https://onetribe.team
    if: ${{ github.event.inputs.environment == 'production' }}
    runs-on: ubuntu-latest
    timeout-minutes: 20
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.workflow_run.head_branch }}

      - name: Pre Build
        uses: ./.github/workflows/pre-build
        with:
          database-url: ${{ secrets.DATABASE_URL_PRODUCTION_ADMIN }}
          redis-url: ${{ secrets.REDIS_URL_PRODUCTION_ADMIN }}
          rails-master-key: ${{ secrets.RAILS_MASTER_KEY }}
          aws-role-access: ${{ secrets.AWS_ROLE_ACCESS }}
          ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }}
          environment: production

      - name: Build and Deploy
        uses: ./.github/workflows/build-deploy
        with:
          environment: production

  build-staging:
    name: deploy-staging
    concurrency:
      group: staging_environment
      cancel-in-progress: true

    # ...
    # staging deploy is similar to production, described above and I will not show it completely. Pull request validation is defined in the , it is the most small and simple workflow. 05.validate_pull_request.yaml It runs specs and lints, triggered by the event and also can be triggered manually. pull_request # 05.validate_pull_request.yaml
name: 05. Validate Pull Request

permissions:
  id-token: write
  contents: read

on:
  pull_request:
  workflow_dispatch:

jobs:
  spec:
    uses: ./.github/workflows/_specs.yaml
    secrets: inherit

  lint:
    uses: ./.github/workflows/_lint_code.yaml
    secrets: inherit The last workflow that I want to cover in this article is the file. Sometimes I need to restart the Traefik container or maybe start or stop accessory containers. I can do it from the local machine, but this requires environment setup and is not always 06.kamal_run_command.yaml convenient. This workflow allows me to run any command from the list of predefined commands. name: 06. Kamal run command

permissions:
  id-token: write
  contents: read

on:
  workflow_dispatch:
    inputs:
      command:
        description: 'Commands'
        required: true
        type: choice
        options:
          - traefik reboot --rolling
          - accessory reboot pg_hero
      environment:
        description: 'Environment'
        required: true
        type: choice
        options:
          - staging
          - production

jobs:
  kamal_run_command:
    name: Kamal run command
    runs-on: ubuntu-latest
    timeout-minutes: 20
    concurrency:
      group: ${{ github.event.inputs.environment }}_environment
      cancel-in-progress: false
    environment:
      name: ${{ github.event.inputs.environment }}
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.workflow_run.head_branch }}

      - uses: ./.github/workflows/pre-build
        name: Pre Build
        with:
          database-url: ${{ github.event.inputs.environment == 'production' && secrets.DATABASE_URL_PRODUCTION || secrets.DATABASE_URL_STAGING }}
          redis-url: ${{ github.event.inputs.environment == 'production' && secrets.REDIS_URL_PRODUCTION || secrets.REDIS_URL_STAGING }}
          rails-master-key: ${{ secrets.RAILS_MASTER_KEY }}
          aws-role-access: ${{ secrets.AWS_ROLE_ACCESS }}
          ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }}
          environment: ${{ github.event.inputs.environment }}

      - name: kamal ${{ github.event.inputs.command }} --destination=${{ github.event.inputs.environment }}
        run: |
          ./bin/kamal ${{ github.event.inputs.command }} --destination=${{ github.event.inputs.environment }} Conclusion The action has grown from a simple 30-line action to a set of reusable workflows and composite actions. It is now full-featured, configurable, and reusable. It allows me to run deploy to different environments, run deploy without running specs and lints, and restart Traefik containers and accessories. I have used this or a similar setup of workflows for about six months and what can I say? It covers all my needs and can be easily adapted for any new features. I hope this article will help you to build your action and workflows. If you have any questions, feel free to ask me in the comments. Also published . here

Building a Reusable Deployment Workflow with Kamal and GitHub Actions

The United States v Meta Platforms Court Filing October 24, 2023 is part of . You can jump to any part in this filing . This is part 95 of 100. HackerNoon’s Legal PDF Series here COUNT L: VIOLATION OF THE SOUTH CAROLINA UNFAIR TRADE PRACTICES ACT, S.C. CODE ANN. SECTION 39-5-10 et seq. 1141. The State of South Carolina realleges and reaffirms each and every allegation set forth in all preceding paragraphs as if fully restated in this section. 1142. The State of South Carolina brings this claim under the South Carolina Unfair Trade Practices Act (SCUTPA), asserting a claim under sections 39-5-50 and 39-5-110 of the South Carolina Code. 1143. Section 39-5-10 et seq. of the South Carolina Code prohibits unfair or deceptive acts or practices in the conduct of any trade or commerce. 1144. Meta’s acts and practices as described in this Complaint constitute “trade” or “commerce” within the meaning of SCUTPA. 1145. Meta engaged in unfair and/or deceptive acts or practices within the meaning of Section 39-5-20 of the South Carolina Code through, inter alia, acts and omissions that caused young users’ compulsive and unhealthy use of and addiction to Meta’s Social Media Platforms. 1146. Meta’s misrepresentations are deceptive because they have the capacity to mislead a substantial number of consumers. 1147. An act or practice may be unfair if it offends public policy; is immoral, unethical, oppressive, unconscionable, or causes injury to consumers. Meta’s acts or practices as alleged in this Complaint are unfair. 1148. Meta’s unfair and deceptive conduct related to addicting young users to its Platforms affects the public interest. Moreover, Meta’s acts or practices regarding South Carolina as alleged herein are capable of repetition. 1149. Meta knew or reasonably should have known that its conduct violated SCUTPA and therefore is willful for the purposes of section 39-5-110 of the South Carolina Code, justifying civil penalties. 1150. The State of South Carolina seeks all remedies available under SCUTPA including, without limitation, the following: a. Injunctive and other equitable relief pursuant to section 39-5-50(a) of the South Carolina Code; b. Restoration of all ascertainable losses under section 39-5-50(b) of the South Carolina Code to any person or entity who suffered them as a result of Meta’s conduct; c. Civil penalties in an amount up to $5,000.00 per violation with every unfair or deceptive act or practice by Meta constituting a separate and distinct violation; and d. Costs and attorneys’ fees pursuant to section 1-7-85 of the South Carolina Code. Continue Reading . Here About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings. This court case 4:23-cv-05448 retrieved on October 25, 2023, from is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. Washingtonpost.com

Stories, News & Mentions about AETION

Aetion’s Stories on HackerNoon