The credit ratings firm will pay State Street CFO Eric Aboaf a $2.4 million signing bonus when he takes their top financial seat in February.

S&P Global swipes State Street CFO for finance chief | CFO Dive

Bank of America earnings beat analyst estimates, but profit did drop following a decrease in net interest income.Yahoo Finance's trending tickers include Arm Holdings (ARM), Nvidia Corporation (NVDA), and Trump Media & Technology Group Corp. (DJT). 9:05 a.m. ET Nathan Stovall, S&P Global Market ...

Bank of America, Citigroup, Goldman Sachs report: Yahoo Finance

Nvidia's partners are showing that the AI titan has "strong runway" for at least the next year, one analyst says.

Nvidia stock can climb for the next 12 months, S&P Global analyst says

The stock of S&P Global Inc (SPGI) has gone up by 0.39% for the week, with a -4.75% drop in the past month and a -11.40% drop in the past quarter. The volatility ratio for the week is 2.06%, and the volatility levels for the past 30 days are 2.

Understanding the 2.05% Volatility Levels of S&P Global Inc’s (SPGI) Stock in the Past 30 Days

When technological advancements and market fluctuations run in parallel, challenges are present, but so are opportunities. The global energy storage markets exemplify this.

What opportunities has the power shortage in Europe offered to Chinese companies?

The rise in Halloween candy spending could be partly attributed to candy and gum prices growing by 7.5% year-over-year during September 2023.

Americans Will Spend Over $12B on Candy for Halloween

Digital business services company honored for customer-centric immersive experiences and revolutionary solutions that helped gained client

Teleperformance Recognized by Frost & Sullivan for Omnichannel Customer Experience in the metaverse

Teleperformance, a global leader in digital business services, today announced that Frost & Sullivan recognized the company with the 2023 Global Company of the Year Award for its industry excellence in omnichannel customer experience in the metaverse.

Government and business leaders from Global South call for a coordinated effort to accelerate growth of carbon markets at COP28

Riyadh hosts Global South Carbon Markets Conference ahead of COP28

Yes, there are stringent regulations that the banks are worried about. So, the use cases where they've adopted AI have, until now, been in places that auditors have scored as low risk. Areas like customer service, where they've used things like text analytics and simplistic AI. But now generative AI is coming into the picture.

AI safety use cases - signing off on Financial Services’ ‘black box’

S&P Global

spglobal

Authors:
(1) Aarav Patel, Amity Regional High School – email: aarav.dhp@gmail.com;
(2) Peter Gloor, Center for Collective Intelligence, Massachusetts Institute of Technology and Corresponding author – email: pgloor@mit.edu. Table of Links Abstract and Introduction
Related Works
Purpose
Methods
Results
Discussion
Conclusion and Bibliography 7. Conclusion The proposed ESG analysis algorithm can help standardize ESG evaluation for all companies. This is because it limits self-reporting bias by incorporating outside social network analysis for more balanced results. A social-network-based ESG index can also directly show which areas people want to change, which can better focus executive efforts on meaningful change. Additionally, using machine learning, the model can generate a proxy for a company’s social responsibility, which can help determine ESG for smaller companies that do not have analyst coverage. This will help more companies receive ESG ratings in an automated way, which can create a more level playing field between small and large companies and ultimately help more socially responsible firms prevail. Overall, the project can have broad implications for bridging the gap in ESG. This will help rewire large quantities of ESG capital to more sustainable and ethical initiatives. Bibliography A Sokolov, J Mostovoy, J Ding, L Seco. 2021. Building Machine Learning Systems for Automated ESG Scoring. The Journal of Impact and ESG Investing 1 (3), 39-50 A. M. Shahi, B. Issac, and J. R. Modapothala. 2011. Analysis of supervised text classification algorithms on corporate sustainability reports. In Proceedings of 2011 International Conference on Computer Science and Network Technology, Vol. 1. 96–100 Akbik, Blythe, and Vollgraf. “Contextual String Embeddings for Sequence Labeling.” Proceedings of the 27th International Conference on Computational Linguistics, pages 1638–1649 Santa Fe, New Mexico, USA, August 20-26, 2018 Andrea Venturelli, Fabio Caputo, Rossella Leopizzi, Giovanni Mastroleo, and Chiara Mio. 2017. How can CSR identity be evaluated? A pilot study using a Fuzzy Expert System. Journal of Cleaner Production 141 (2017), 1000 – 1010. Awad, M., Khanna, R. (2015). Support Vector Regression. In: Efficient Learning Machines. Apress, Berkeley, CA. https://doi.org/10.1007/978-1-4302-5990-9_4 Berg, Florian, et al. “Aggregate Confusion: The Divergence of ESG Ratings.” SSRN Electronic Journal, 2019, doi:10.2139/ssrn.3438533. CDP. (2017, July 10). New report shows just 100 companies are source of over 70% of emissions. Retrieved May 24, 2022, from http://www.cdp.net/en/articles/ media/new-report-shows-just-100-companies-are-source-of-over-70-of-emissions Chen Tianqi, and Guestrin Carlos. “XGBoost: A Scalable Tree Boosting System.” KDD '16: Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, August 2016, Pages 785-794, doi: 10.1145/2939672.2939785 de Beer D, Matthee M. Approaches to Identify Fake News: A Systematic Literature Review. Integrated Science in Digital Age 2020. 2020 May 5;136:13–22. doi: 10.1007/978-3-030- 49264-9_2. PMCID: PMC7250114. Oliver Kramer. Dimensionality Reduction with Unsupervised Nearest Neighbors, 2013, Volume 51, ISBN: 978-3-642-38651-0 Drempetic, Samuel, et al. “The Influence of Firm Size on the ESG Score: Corporate Sustainability Ratings Under Review.” Journal of Business Ethics, vol. 167, no. 2, 2019, pp. 333–360., doi:10.1007/s10551-019-04164-1 Gloor, Peter A., et al. “Web Science 2.0: Identifying Trends through Semantic Social Network Analysis.” 2009 International Conference on Computational Science and Engineering, 2009, doi:10.1109/cse.2009.186. Ho, T. K. (1995). Random decision forests. In Proceedings of 3rd international conference on document analysis and recognition (Vol. 1, pp. 278–282). Jain, M., Sharma, G. D., & Srivastava, M. (2019). Can sustainable investment yield better financial returns: A comparative study of ESG indices and MSCI indices. Risks, 7(1), 15. https://doi.org/10.3390/risks7010015 Kotsantonis, Sakis, and George Serafeim. “Four Things No One Will Tell You About ESG Data.” Journal of Applied Corporate Finance, vol. 31, no. 2, 2019, pp. 50–58., doi:10.1111/jacf.12346 Pavel Wicher, František Zapletal, and Radim Lenort. 2019. Sustainability performance assessment of industrial corporation using Fuzzy Analytic Network Process. Journal of Cleaner Production 241 (2019). Pin-Chao Liao, Ni-Ni Xia, Chun-Lin Wu, Xiao-Ling Zhang, and Jui-Lin Yeh. 2017. Communicating the corporate social responsibility (CSR) of international contractors: Content analysis of CSR reporting. Journal of Cleaner Production 156 (2017), 327–336. Rao, Prashanth. “Fine-Grained Sentiment Analysis in Python (Part 1).” Medium, Towards Data Science, 9 Sept. 2019, towardsdatascience.com/fine-grained-sentiment-analysis-in-pythonpart-1-2697bb111ed4. Ryohei Hisano, Didier Sornette, and Takayuki Mizuno. 2020. Prediction of ESG compliance using a heterogeneous information network. Journal of Big Data 7, 1 (2020), 22 S.-J. Lin and M.-F. Hsu. 2018. Decision making by extracting soft information from CSR news report. Technological and Economic Development of Economy 24, 4 (2018), 1344–1361. S&P Global. (n.d.). ESG Evaluation | S&P Global. Retrieved May 24, 2022, from http://www.spglobal.com/ratings/en/products-benefits/products/esg-evaluation Stackpole, Beth. “Why Sustainable Business Needs Better ESG Ratings.” MIT Sloan, 6 Dec. 2021, mitsloan.mit.edu/ideas-made-to-matter/why-sustainable-business-needs-better-esgratings. shweta-29. “Shweta-29/Companies_ESG_Scraper: This Repository Includes a Tool to Extract Companies' ESG Ratings & Financial Metrics and Load Them on SQL.” GitHub, github.com/shweta-29/Companies_ESG_Scraper T Krappel, A Bogun, D Borth. 2021. Heterogeneous Ensemble for ESG Ratings Prediction. KDD Workshop on Machine Learning in Finance United Nations Global Compact. (2016). The UN Global Compact-Accenture Strategy CEO Study 2016. Retrieved May 26, 2022, from https://www.unglobalcompact.org/library/4331 United Nations Global Compact. (2019). UN Global Compact - Accenture Strategy 2019 CEO Study – The Decade to Deliver: A Call to Business Action. Retrieved May 26, 2022, from https://www.unglobalcompact.org/library/5715 This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: (1) Aarav Patel, Amity Regional High School – email: aarav.dhp@gmail.com; (2) Peter Gloor, Center for Collective Intelligence, Massachusetts Institute of Technology and Corresponding author – email: pgloor@mit.edu. Authors: Authors: (1) Aarav Patel, Amity Regional High School – email: aarav.dhp@gmail.com; (2) Peter Gloor, Center for Collective Intelligence, Massachusetts Institute of Technology and Corresponding author – email: pgloor@mit.edu. Table of Links Abstract and Introduction Related Works Purpose Methods Results Discussion Conclusion and Bibliography Abstract and Introduction Abstract and Introduction Related Works Related Works Purpose Purpose Methods Methods Results Results Discussion Discussion Conclusion and Bibliography Conclusion and Bibliography 7. Conclusion The proposed ESG analysis algorithm can help standardize ESG evaluation for all companies. This is because it limits self-reporting bias by incorporating outside social network analysis for more balanced results. A social-network-based ESG index can also directly show which areas people want to change, which can better focus executive efforts on meaningful change. Additionally, using machine learning, the model can generate a proxy for a company’s social responsibility, which can help determine ESG for smaller companies that do not have analyst coverage. This will help more companies receive ESG ratings in an automated way, which can create a more level playing field between small and large companies and ultimately help more socially responsible firms prevail. Overall, the project can have broad implications for bridging the gap in ESG. This will help rewire large quantities of ESG capital to more sustainable and ethical initiatives. Bibliography A Sokolov, J Mostovoy, J Ding, L Seco. 2021. Building Machine Learning Systems for Automated ESG Scoring. The Journal of Impact and ESG Investing 1 (3), 39-50 A. M. Shahi, B. Issac, and J. R. Modapothala. 2011. Analysis of supervised text classification algorithms on corporate sustainability reports. In Proceedings of 2011 International Conference on Computer Science and Network Technology, Vol. 1. 96–100 Akbik, Blythe, and Vollgraf. “Contextual String Embeddings for Sequence Labeling.” Proceedings of the 27th International Conference on Computational Linguistics, pages 1638–1649 Santa Fe, New Mexico, USA, August 20-26, 2018 Andrea Venturelli, Fabio Caputo, Rossella Leopizzi, Giovanni Mastroleo, and Chiara Mio. 2017. How can CSR identity be evaluated? A pilot study using a Fuzzy Expert System. Journal of Cleaner Production 141 (2017), 1000 – 1010. Awad, M., Khanna, R. (2015). Support Vector Regression. In: Efficient Learning Machines. Apress, Berkeley, CA. https://doi.org/10.1007/978-1-4302-5990-9_4 Berg, Florian, et al. “Aggregate Confusion: The Divergence of ESG Ratings.” SSRN Electronic Journal, 2019, doi:10.2139/ssrn.3438533. CDP. (2017, July 10). New report shows just 100 companies are source of over 70% of emissions. Retrieved May 24, 2022, from http://www.cdp.net/en/articles/ media/new-report-shows-just-100-companies-are-source-of-over-70-of-emissions Chen Tianqi, and Guestrin Carlos. “XGBoost: A Scalable Tree Boosting System.” KDD '16: Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, August 2016, Pages 785-794, doi: 10.1145/2939672.2939785 de Beer D, Matthee M. Approaches to Identify Fake News: A Systematic Literature Review. Integrated Science in Digital Age 2020. 2020 May 5;136:13–22. doi: 10.1007/978-3-030- 49264-9_2. PMCID: PMC7250114. Oliver Kramer. Dimensionality Reduction with Unsupervised Nearest Neighbors, 2013, Volume 51, ISBN: 978-3-642-38651-0 Drempetic, Samuel, et al. “The Influence of Firm Size on the ESG Score: Corporate Sustainability Ratings Under Review.” Journal of Business Ethics, vol. 167, no. 2, 2019, pp. 333–360., doi:10.1007/s10551-019-04164-1 Gloor, Peter A., et al. “Web Science 2.0: Identifying Trends through Semantic Social Network Analysis.” 2009 International Conference on Computational Science and Engineering, 2009, doi:10.1109/cse.2009.186. Ho, T. K. (1995). Random decision forests. In Proceedings of 3rd international conference on document analysis and recognition (Vol. 1, pp. 278–282). Jain, M., Sharma, G. D., & Srivastava, M. (2019). Can sustainable investment yield better financial returns: A comparative study of ESG indices and MSCI indices. Risks, 7(1), 15. https://doi.org/10.3390/risks7010015 Kotsantonis, Sakis, and George Serafeim. “Four Things No One Will Tell You About ESG Data.” Journal of Applied Corporate Finance, vol. 31, no. 2, 2019, pp. 50–58., doi:10.1111/jacf.12346 Pavel Wicher, František Zapletal, and Radim Lenort. 2019. Sustainability performance assessment of industrial corporation using Fuzzy Analytic Network Process. Journal of Cleaner Production 241 (2019). Pin-Chao Liao, Ni-Ni Xia, Chun-Lin Wu, Xiao-Ling Zhang, and Jui-Lin Yeh. 2017. Communicating the corporate social responsibility (CSR) of international contractors: Content analysis of CSR reporting. Journal of Cleaner Production 156 (2017), 327–336. Rao, Prashanth. “Fine-Grained Sentiment Analysis in Python (Part 1).” Medium, Towards Data Science, 9 Sept. 2019, towardsdatascience.com/fine-grained-sentiment-analysis-in-pythonpart-1-2697bb111ed4. Ryohei Hisano, Didier Sornette, and Takayuki Mizuno. 2020. Prediction of ESG compliance using a heterogeneous information network. Journal of Big Data 7, 1 (2020), 22 S.-J. Lin and M.-F. Hsu. 2018. Decision making by extracting soft information from CSR news report. Technological and Economic Development of Economy 24, 4 (2018), 1344–1361. S&P Global. (n.d.). ESG Evaluation | S&P Global. Retrieved May 24, 2022, from http://www.spglobal.com/ratings/en/products-benefits/products/esg-evaluation Stackpole, Beth. “Why Sustainable Business Needs Better ESG Ratings.” MIT Sloan, 6 Dec. 2021, mitsloan.mit.edu/ideas-made-to-matter/why-sustainable-business-needs-better-esgratings. shweta-29. “Shweta-29/Companies_ESG_Scraper: This Repository Includes a Tool to Extract Companies' ESG Ratings & Financial Metrics and Load Them on SQL.” GitHub, github.com/shweta-29/Companies_ESG_Scraper T Krappel, A Bogun, D Borth. 2021. Heterogeneous Ensemble for ESG Ratings Prediction. KDD Workshop on Machine Learning in Finance United Nations Global Compact. (2016). The UN Global Compact-Accenture Strategy CEO Study 2016. Retrieved May 26, 2022, from https://www.unglobalcompact.org/library/4331 United Nations Global Compact. (2019). UN Global Compact - Accenture Strategy 2019 CEO Study – The Decade to Deliver: A Call to Business Action. Retrieved May 26, 2022, from https://www.unglobalcompact.org/library/5715 This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. available on arxiv

Creating a Systematic ESG Scoring System: Conclusion and Bibliography

একটি পদ্ধতিগত ESG স্কোরিং সিস্টেম তৈরি করা: উপসংহার এবং গ্রন্থপঞ্জি

Erstellen eines systematischen ESG-Bewertungssystems: Schlussfolgerung und Bibliographie

Creación de un sistema sistemático de puntuación ESG: conclusión y bibliografía

Créer un système de notation ESG systématique : conclusion et bibliographie

एक व्यवस्थित ईएसजी स्कोरिंग सिस्टम बनाना: निष्कर्ष और ग्रंथ सूची

体系的な ESG スコアリング システムの作成: 結論と参考文献

체계적인 ESG 채점 시스템 구축: 결론 및 참고문헌

Criando um Sistema Sistemático de Pontuação ESG: Conclusão e Bibliografia

Создание систематической системы оценки ESG: заключение и библиография

Sistematik bir ESG Puanlama Sistemi Oluşturma: Sonuç ve Kaynakça

Tạo hệ thống tính điểm ESG có hệ thống: Kết luận và tài liệu tham khảo

创建系统的 ESG 评分体系：结论和参考书目

What should Ukrainian companies pay attention to become popular in the international private capital market? “Global M&A activity has significantly declined”, “For the first time since 2019, no mega-deal was concluded during the quarter”, and “M&A companies are no longer willing to take risks” — these were the headlines that appeared one after another in 2022. The hint was obvious: the entire sector is going through difficult times. However, is the M&A market truly in a crisis? Short answer: No. Substantive answer: What was yesterday's sign of crisis is now impacting trends. To get the long answer, it is enough to read our full report. The thing is that once you start to examine the situation closely, something else will open up: the resilience of the M&A market to geopolitical tensions, recession-related issues, and a whole array of preconditions for the 2023 trends. The beginning of the year is usually the best time frame to dive into all possible forecasts and outliers, and the M&A sphere is no exception. We have analyzed the main trends that will influence the market and our activities both in Ukraine and in Europe and other countries and are ready to share them with you. M&A and IT trends in 2023 “Smaller deals and slower pace” – the smaller the deals, the greater the chances of success. Medium-sized companies with 200+ employees are more interesting to acquire. “Now is not the time to fall out of love with M&A” (according to PwC) – M&A will remain the basis of expansion of new customers and sales from the local market to the global one. A challenging but optimistic year – a forecast of deals that will be smaller in value, but possibly more in number. The M&A market in both global and local contexts can intersect and influence one another, yet tendencies tend to form differently. What will be the prevailing trends in the global context? The primary driving force of change in the market is a substantial slowdown in deal volume compared to the record-breaking pace set last year. In 2022, M&A was impacted by numerous factors such as geopolitical shocks, a sharp increase in inflation, and higher interest rates, all of which will remain in effect in 2023. According to Duncan Smithson, Senior Director of the M&A division at WTW, 5 key M&A trends for 2023 are: – meaning a return to small deals (up to $1 billion). Return of the 'small item effect' Opportunities in troubled M&A. A challenging operating environment will cause a growing number of companies to shed non-core assets in pursuit of long-term value creation. Technological M&A: In 2023, a wave of acquisitions is expected in the artificial intelligence and machine learning markets. Whether leveraging new technology and talent or entering new markets, mergers and acquisitions remain the fastest way to transform businesses. Geopolitical influence. After the military aggression of russia in the attack on Ukraine, almost everyone gave up on the market of the Asian aggressor. Therefore, Ukrainian companies have a chance that after the end of the war and the victory of Ukraine, the M&A market here will shine bright. Even during the war, we at Mergewave Capital were approached by many buyers and sellers who wanted to buy or sell businesses from Ukraine. Focus on Environmental, Social, and Governance (ESG) An acquirer's due diligence will be more important than ever, businesses will face mounting scrutiny and pressure for transparency on climate risk, social justice, sustainability, and corporate governance. “Green” due diligence is, without a doubt, on the up. Considering the number of mergers and acquisitions in the United States fell about 43% to $1.53 trillion, while in Europe and Asia Pacific, it decreased by 27% and 30%, respectively, with volumes just over the $900 billion mark, we expect the increase in activity of American companies. European M&A market and the impact of Scandinavian countries As for the European market, CMS, together with Mergermarket, highlight the following possible events: M&A expectations are high: 73% of deal participants expect the level of M&A activity in Europe to increase over the next 12 months. Almost everyone is now considering M&A; is expected to be the presence of undervalued target deals, while on the Sell-side it will be complex situations and negotiations; The biggest driver on the Buy-side : The cost of raising financing will increase 87% of deal participants expect financing to be tighter compared to 2021/2022. This is due to the difficulty of finding relevant companies; : ESG is moving up the M&A agenda 90% of respondents expect ESG to increase focus on their deals over the next three years. Take the processing sector, which aims to close the economic loop for other industries such as packaging. This explains the high level of M&A activity in this processing sector. Market participants are aware that there will be a high demand for secondary raw materials on the market. The Scandinavian region is traditionally a major influence on the global market situation. What were the results of Scandinavian countries in 2022? In the first half of 2022, 962 deals worth 56.3 billion euros were concluded in the Scandinavian region. This was a significant 11% drop in volume compared to the previous year, although the value was up 7%. In comparison, overall European M&A also got an 8% decline in volume and a 1% increase in value. There was an encouraging recovery in M&A in the Nordics, which contrasted with weakness in capital markets, where we could see fewer IPOs due to high-interest rates, inflation, and more expensive capital. Private equity still leads the region, with PE firms strongly represented in the top 20 acquisitions in the Nordics during the first half of the year. Many of the leading Nordic PE players have been actively raising money and have seen large deals involving them (e.g. Axcel in Denmark, EQT in Sweden, and HitecVision in Norway). How did the volume of deals change and what to expect in 2023? In its annual report, PwC provides data on CEOs of companies that do not plan to delay M&A deals: We can see that the 2 largest sectors are Technology, Telecom, Media (Marketing), and Financial Services (Fintech, Neobanks) with 64% and 65% respectively. For us [ ], this means that we are moving in the right direction, as most of our sell-sides are from these industries.
As for the volume of deals, a decrease in both the value and the total number of deals was observed in the European region ($255 billion (not including mega deals) for the II half of 2022 by 8,976 deals), i.e. the average deal was at the level of $28.4M. Mergewave Capital As Reuters notes, “Some sellers are still hoping for yesterday's price, and some buyers are still hoping for yesterday's financing, even though those things are no longer available. That's why we're seeing smaller activity,” said Dirk Albersmeier, co-head of global M&A at JPMorgan. At the same time, S&P Global Market also confirms the hypothesis of a decrease in the average value of transactions. For example, , but the financial sector gives a higher value of $120.5M due to the complexity of the business and the value of financial institutions' assets. The energy sector is also becoming interesting, especially in connection with the bombing of the critical infrastructure of Ukraine by russian missiles. A certain increase in interest in this area and alternative energy sources (solar, wind, hydro, etc.) is predicted to be $130.7 million. the average value of IT sector deals is $11.2M Conclusion Given the cautious forecasts for the M&A market on a global and local scale, we can say that our hypotheses regarding development, tendencies, and trends in 2023 are confirmed, including by well-known giants. Based on the fact that the M&A market is decreasing in terms of value, but not the number of deals, we assume that the IT, financial, energy, and service sectors will be heard in deals this year. Technical – since the average cost varies within $10M and technologies are just developing, in particular blockchain and Web3, AI, and ML – and this is quite an optimal cost for companies with 50-200+ people (depending on their financial indicators and technology stack); financial – because there is always a demand for fintech, neo banks, and payment services for large market giant banks; energy – because it is an infrastructural component that is unmanageable to do without (Internet, lighting, food, etc.). Therefore, Ukrainian companies can create synergy and add value in this M&A market precisely in these sectors. The M&A market is rapidly changing, leaving behind the trends of past years. If mega deals used to be the foundation of the market’s ‘’health’’, we now see the opposite situation: a shift towards smaller deals that promise stability. This is the situation and “standard” that must be taken into account to maintain the “health” of a company and keep favorable positions. If you are unsure of the timing of a deal or its structure, contact us at We are an M&A brokerage with expertise in the IT, FinTech, and Blockchain sectors. Our team has already closed over 60 deals, including those that emerged in crisis. We will help you properly build your M&A strategy, conduct scouting, structure the deal, and provide advice on any aspect of the process. Mergewave Capital. References: Global M&A Outlook 2023: Smaller deals and slower pace – WTW (wtwco.com) A study of European M&A activity in 2023 | Boom & Gloom? CMS Outlook CMS | Spotlight on M&A in the Nordics Global M&A Industry Trends: 2023 Outlook: PwC Dealmakers brace for slow 2023 recovery after global M&A sinks | Reuters The Big Picture: 2023 M&A Outlook | S&P Global Market Intelligence (spglobal.com)

The Main M&A Trends and Tendencies Analysis for 2023

CIA Supervisor: Jesus F***ing Christ. What did we learn, Palmer? Palmer: I don't know sir. CIA Supervisor: I don't f***ing know either. I guess we learned not to do it again. I'm f***ed if I know what we did. Palmer: Yes sir, it's hard to say. Many people erroneously believe that the 2008 crisis was about people getting home mortgages and not paying them back. That is true, but it is only part of the truth. In reality, the consequences wouldn’t be so dramatic if it wasn’t for financers that thought it would be a great idea to repackage hundreds of billions of dollars in mortgages into something called collateralized debt obligations (CDOs). As Mark Baum said in The Big Short: “mortgage bonds are dog shit. CDOs are dog shit wrapped in cat shit.” Theoretically, CDOs were supposed to shift risk from banks. Unfortunately, banks are not charities and they exist to make money. Thus, it shouldn’t be a surprise that banks that issued home loans also bet on CDOs. Major rating agencies, on the other hand, were very slow in revising the rating of Collateralized Debt Obligations (CDOs). The reasoning was also explained in The Big Short: Two hedge fund managers visit a Standard & Poor’s executive in her office in Manhattan. One asks the exec to name a time in the past year when the company didn’t give a bank the AAA rating it was seeking. She demurs. “If we don’t work with them,” she says, “they will go to our competitors. It’s not our fault. It’s simply the way the world works.” As a result, when the bubble burst, those banks were doubly punched. Lehman Brothers went bankrupt, meanwhile, Merrill Lynch, AIG, Freddie Mac, Fannie Mae, HBOS, Royal Bank of Scotland, Bradford & Bingley, Fortis, Hypo, and Alliance & Leicester had to be rescued. The "funny" part of that is that these banks were supposed to be backed up by teams of math whizzes and computer geniuses, even though they managed to lose billions of dollars. As a result, the crisis of confidence has infected the world, driving the dollar to record lows - and helping send the prices of commodities, especially oil, soaring to historic highs. Curiously, we do observe a fall in the dollar now but the prices of commodities also suffered. It is worth mentioning that with the Subprime crisis, Wall Street banks couldn’t even calculate how much risky securities on their books were really worth. In conference calls and press releases, they have been changing their estimates of the value of these assets. Merrill Lynch, for , expected a $4.5 billion subprime loss for the third quarter, but three weeks later, its analysts announced that its real deficit was $7.9 billion. Probably, it wasn’t the best idea to become a huge investor in the funds it assisted. But, as the saying goes, big chances are never small stakes. example Howbeit, investors couldn’t trust management's estimates of future losses anymore. Today, we see that time cures everything, which is why was able to operate without being objected to by the auditors for such a long time… Wirecard AG This brings us to the idea that when Wall Street is bringing its attention to mysterious products and complex trades, the game is on and so is a risk. The only question is when it will hit the market. But did we learn something? It has been recently announced that the first ETF Tracking the $700 Billion CLO-Market begins trading on the New York Stock Exchange. According to co-founder Peter Copp, the fund will track the highest-rated CLOs. “These particular bonds have maintained their AAA rating through a variety of market selloffs, and we think that’s a testimony to it being a good product and reasonable for retail investors to have access,” Coppa said. It is important to highlight that ETF could make CLOs more accessible to retail investors and this can be dangerous in case something goes wrong, again. Alternative Access Funds Some are scared that if the economy continues , corporate loan defaults could rise, leading to a wave of CLO write-downs and default—as it happened with CDOs in 2008. It should be mentioned that the structure of CLOs to CDOs from the economic perspective. Each pools multiple loans to create synthetic, bond-like investments. Investors buy a slice (or tranche) of the underlying interest and principal cash flows of the portfolio. A defined order of which investors get repaid first and which bear the most losses allocates risk differentially. to suffer from COVID-19 According to , Japan's top CLO investor, Norinchukin Bank, told in May that it would refrain from investing in more CLOs. Despite the fact that the default risk of CLOs appears low for now, rising risk aversion among investors had led to an unrealized loss of about ¥400 billion of its CLO portfolio in the March-end quarter. SPGlobal On the positive side, CLOs have greater protection in comparison with CDOs, as repackage corporate loans, primarily leveraged loans, as well as consumer credit such as automobile loans. Besides that, higher levels of losses are required before they lose money. Even though they are still pretty risky. Probably, it would be rational for investors to check the credit quality of the leveraged loans, which underlie the bulk of CLOs before anything. The information set forth herein has been obtained or derived from sources believed by the author to be reliable. However, the author does not make any representation or warranty, express or implied, as to the information's accuracy or completeness. Nor does the author recommend that the attached information serve as the basis of any investment decision and it has been provided to you solely for informational purposes only and does not constitute an offer or solicitation of an offer, or any advice or recommendation, to purchase any securities or other financial instruments, and may not be construed as such. Disclosure:

Subprime 2.0 – Is 2008 is back?

When developing applications with Golang, one of the common challenges faced is memory management. Golang uses two primary memory storage locations: the stack and the heap. Understanding when a variable is allocated to the heap versus the stack is crucial for optimizing the performance of the applications we build. In this article, we will explore the key conditions that cause a variable to be allocated to the heap and introduce the concept of escape analysis, which the Go compiler uses to determine memory allocation. TL;DR In Golang, variables can be allocated on the heap or the stack. Heap allocation occurs when a variable needs to outlive the function scope or a larger object. Go uses escape analysis to determine whether a variable should be allocated on the heap. Heap allocation happens in the following scenarios: Variables "escape" the function or scope.
Variables are stored in locations with longer lifecycles, such as global variables.
Variables are placed into structs used outside the function.
Large objects are allocated on the heap to avoid using a large stack.
Closures that store references to local variables trigger heap allocation.
When variables are cast to an interface, heap allocation often occurs. Heap allocation is slower because memory is managed by the Garbage Collector (GC), so it’s crucial to minimize its usage. What are the Stack and Heap? Before diving into the main topic, let's first understand the differences between the stack and heap. Stack: Stack memory is used to store local variables from a function or goroutine. The stack operates in a last-in, first-out (LIFO) manner, where the most recent data is the first to be removed. Variables allocated on the stack only live as long as the function is being executed and are automatically removed when the function exits its scope. Allocation and deallocation on the stack are very fast, but the stack size is limited.
Heap: Heap memory is used to store objects or variables that need to persist beyond the lifecycle of a function. Unlike the stack, the heap does not follow a LIFO pattern and is managed by the Garbage Collector (GC), which periodically cleans up unused memory. While the heap is more flexible for long-term storage, accessing heap memory is slower and requires additional management by the GC. What is Escape Analysis? Escape analysis is a process performed by the Go compiler to determine whether a variable can be allocated on the stack or needs to be moved to the heap. If a variable "escapes" the function or scope, it will be allocated on the heap. Conversely, if the variable remains within the function scope, it can be stored on the stack. When is a Variable Allocated to the Heap? Several conditions cause variables to be allocated on the heap. Let's discuss each situation. 1. When a Variable "Escapes" from a Function or Scope Heap allocation occurs when a variable is declared inside a function, but its reference escapes the function. For example, when we return a pointer to a local variable from a function, that variable will be allocated on the heap. For instance: func newInt() *int {
    x := 42
    return &x // "x" is allocated on the heap because a pointer is returned
} In this example, the variable x must remain alive after the function newInt() finishes, so Go allocates x on the heap. 2. When a Variable is Stored in a Longer-Lived Location If a variable is stored in a location with a lifecycle longer than the scope where the variable is declared, it will be allocated on the heap. A classic example is when a reference to a local variable is stored in a global variable or a struct that lives longer. For example: var global *int

func setGlobal() {
    x := 100
    global = &x // "x" is allocated on the heap because it's stored in a global variable
} Here, the variable x needs to survive beyond the setGlobal() function, so it must be allocated on the heap. Similarly, when a local variable is placed into a struct used outside the function where it was created, that variable will be allocated on the heap. For example: type Node struct {
    value *int
}

func createNode() *Node {
    x := 50
    return &Node{value: &x} // "x" must be on the heap because it's stored in Node
} In this example, since x is stored in Node and returned from the function, x must outlive the function, and thus it is allocated on the heap. 3. For Large Objects Sometimes, heap allocation is necessary for large objects, such as large arrays or slices, even if the objects don't "escape." This is done to avoid using too much stack space. For example: func largeSlice() []int {
    return make([]int, 1000000) // Heap allocation due to large size
} Golang will use the heap to store this large slice because its size is too large for the stack. 4. Closures that Store References to Local Variables Closures in Golang often lead to heap allocation if the closure holds a reference to a local variable in the function where the closure is defined. For example: func createClosure() func() int {
    x := 10
    return func() int { return x } // "x" must be on the heap because it's used by the closure
} Since the closure func() int holds a reference to x, x must be allocated on the heap to ensure it remains alive after the createClosure() function finishes. 5. Interfaces and Dynamic Dispatch When variables are cast to an interface, Go may need to store the dynamic type of the variable on the heap. This happens because information about the variable's type needs to be stored alongside its value. For example: func asInterface() interface{} {
    x := 42
    return x // Heap allocation because the variable is cast to interface{}
} In this case, Go will allocate x on the heap to ensure the dynamic type information is available. Other Factors That Cause Heap Allocation In addition to the conditions mentioned above, there are several other factors that may cause variables to be allocated on the heap: 1. Goroutines Variables used within goroutines are often allocated on the heap because the lifecycle of a goroutine can extend beyond the function in which it was created. 2. Variables Managed by the Garbage Collector (GC) If Go detects that a variable needs to be managed by the Garbage Collector (GC) (for example, because it's used across goroutines or has complex references), that variable may be allocated on the heap. Conclusion Understanding when and why a variable is allocated on the heap is crucial for optimizing the performance of Go applications. Escape analysis plays a key role in determining whether a variable can be allocated on the stack or must be allocated on the heap. While the heap provides flexibility for storing objects that need a longer lifespan, excessive heap usage can increase the workload of the Garbage Collector and slow down application performance. By following these guidelines, you can manage memory more efficiently and ensure your application runs with optimal performance. If there’s anything you think I’ve missed or if you have additional experience and tips related to memory management in Go, feel free to share them in the comments below. Further discussion can help all of us better understand this topic and continue developing more efficient coding practices. When developing applications with Golang, one of the common challenges faced is memory management . Golang uses two primary memory storage locations: the stack and the heap . Understanding when a variable is allocated to the heap versus the stack is crucial for optimizing the performance of the applications we build. In this article, we will explore the key conditions that cause a variable to be allocated to the heap and introduce the concept of escape analysis , which the Go compiler uses to determine memory allocation . memory management stack heap heap stack escape analysis memory allocation TL;DR TL;DR In Golang, variables can be allocated on the heap or the stack. Heap allocation occurs when a variable needs to outlive the function scope or a larger object. Go uses escape analysis to determine whether a variable should be allocated on the heap. escape analysis Heap allocation happens in the following scenarios: Variables "escape" the function or scope. Variables are stored in locations with longer lifecycles, such as global variables. Variables are placed into structs used outside the function. Large objects are allocated on the heap to avoid using a large stack. Closures that store references to local variables trigger heap allocation. When variables are cast to an interface, heap allocation often occurs. Variables "escape" the function or scope. Variables are stored in locations with longer lifecycles , such as global variables . lifecycles global variables Variables are placed into structs used outside the function . outside function Large objects are allocated on the heap to avoid using a large stack . large stack Closures that store references to local variables trigger heap allocation. Closures store references When variables are cast to an interface , heap allocation often occurs. interface Heap allocation is slower because memory is managed by the Garbage Collector (GC) , so it’s crucial to minimize its usage. Garbage Collector (GC) What are the Stack and Heap? Before diving into the main topic, let's first understand the differences between the stack and heap . stack heap Stack: Stack memory is used to store local variables from a function or goroutine. The stack operates in a last-in, first-out (LIFO) manner, where the most recent data is the first to be removed. Variables allocated on the stack only live as long as the function is being executed and are automatically removed when the function exits its scope. Allocation and deallocation on the stack are very fast, but the stack size is limited. Heap: Heap memory is used to store objects or variables that need to persist beyond the lifecycle of a function. Unlike the stack, the heap does not follow a LIFO pattern and is managed by the Garbage Collector (GC), which periodically cleans up unused memory. While the heap is more flexible for long-term storage, accessing heap memory is slower and requires additional management by the GC. Stack : Stack memory is used to store local variables from a function or goroutine. The stack operates in a last-in, first-out (LIFO) manner, where the most recent data is the first to be removed. Variables allocated on the stack only live as long as the function is being executed and are automatically removed when the function exits its scope. Allocation and deallocation on the stack are very fast, but the stack size is limited. Stack last-in, first-out (LIFO) Heap : Heap memory is used to store objects or variables that need to persist beyond the lifecycle of a function. Unlike the stack, the heap does not follow a LIFO pattern and is managed by the Garbage Collector (GC) , which periodically cleans up unused memory. While the heap is more flexible for long-term storage, accessing heap memory is slower and requires additional management by the GC. Heap Garbage Collector (GC) slower What is Escape Analysis? Escape analysis is a process performed by the Go compiler to determine whether a variable can be allocated on the stack or needs to be moved to the heap . If a variable "escapes" the function or scope, it will be allocated on the heap. Conversely, if the variable remains within the function scope, it can be stored on the stack. stack heap When is a Variable Allocated to the Heap? Several conditions cause variables to be allocated on the heap. Let's discuss each situation. 1. When a Variable "Escapes" from a Function or Scope Heap allocation occurs when a variable is declared inside a function, but its reference escapes the function. For example, when we return a pointer to a local variable from a function, that variable will be allocated on the heap. For instance: func newInt() *int {
    x := 42
    return &x // "x" is allocated on the heap because a pointer is returned
} func newInt() *int {
    x := 42
    return &x // "x" is allocated on the heap because a pointer is returned
} In this example, the variable x must remain alive after the function newInt() finishes, so Go allocates x on the heap. x newInt() x 2. When a Variable is Stored in a Longer-Lived Location If a variable is stored in a location with a lifecycle longer than the scope where the variable is declared, it will be allocated on the heap. A classic example is when a reference to a local variable is stored in a global variable or a struct that lives longer. For example: var global *int

func setGlobal() {
    x := 100
    global = &x // "x" is allocated on the heap because it's stored in a global variable
} var global *int

func setGlobal() {
    x := 100
    global = &x // "x" is allocated on the heap because it's stored in a global variable
} Here, the variable x needs to survive beyond the setGlobal() function, so it must be allocated on the heap. Similarly, when a local variable is placed into a struct used outside the function where it was created, that variable will be allocated on the heap. For example: x setGlobal() type Node struct {
    value *int
}

func createNode() *Node {
    x := 50
    return &Node{value: &x} // "x" must be on the heap because it's stored in Node
} type Node struct {
    value *int
}

func createNode() *Node {
    x := 50
    return &Node{value: &x} // "x" must be on the heap because it's stored in Node
} In this example, since x is stored in Node and returned from the function, x must outlive the function, and thus it is allocated on the heap. x Node x 3. For Large Objects Sometimes, heap allocation is necessary for large objects, such as large arrays or slices, even if the objects don't "escape." This is done to avoid using too much stack space. For example: func largeSlice() []int {
    return make([]int, 1000000) // Heap allocation due to large size
} func largeSlice() []int {
    return make([]int, 1000000) // Heap allocation due to large size
} Golang will use the heap to store this large slice because its size is too large for the stack. 4. Closures that Store References to Local Variables Closures in Golang often lead to heap allocation if the closure holds a reference to a local variable in the function where the closure is defined. For example: func createClosure() func() int {
    x := 10
    return func() int { return x } // "x" must be on the heap because it's used by the closure
} func createClosure() func() int {
    x := 10
    return func() int { return x } // "x" must be on the heap because it's used by the closure
} Since the closure func() int holds a reference to x , x must be allocated on the heap to ensure it remains alive after the createClosure() function finishes. func() int x x createClosure() 5. Interfaces and Dynamic Dispatch When variables are cast to an interface, Go may need to store the dynamic type of the variable on the heap. This happens because information about the variable's type needs to be stored alongside its value. For example: func asInterface() interface{} {
    x := 42
    return x // Heap allocation because the variable is cast to interface{}
} func asInterface() interface{} {
    x := 42
    return x // Heap allocation because the variable is cast to interface{}
} In this case, Go will allocate x on the heap to ensure the dynamic type information is available. x Other Factors That Cause Heap Allocation In addition to the conditions mentioned above, there are several other factors that may cause variables to be allocated on the heap: 1. Goroutines Variables used within goroutines are often allocated on the heap because the lifecycle of a goroutine can extend beyond the function in which it was created. goroutines heap 2. Variables Managed by the Garbage Collector (GC) If Go detects that a variable needs to be managed by the Garbage Collector (GC) (for example, because it's used across goroutines or has complex references), that variable may be allocated on the heap. Garbage Collector (GC) Conclusion Conclusion Understanding when and why a variable is allocated on the heap is crucial for optimizing the performance of Go applications. Escape analysis plays a key role in determining whether a variable can be allocated on the stack or must be allocated on the heap . While the heap provides flexibility for storing objects that need a longer lifespan, excessive heap usage can increase the workload of the Garbage Collector and slow down application performance. By following these guidelines, you can manage memory more efficiently and ensure your application runs with optimal performance. heap Escape analysis heap heap Garbage Collector slow down If there’s anything you think I’ve missed or if you have additional experience and tips related to memory management in Go, feel free to share them in the comments below. Further discussion can help all of us better understand this topic and continue developing more efficient coding practices.

Optimizing Memory Usage in Golang: When is a Variable Allocated to the Heap

Serverless NestJS Automation on AWS Lambda

Build a Decentralized Freelancer Marketplace With React, Solidity, and CometChat

In the process of learning blockchain programming, whether it's the most popular on YouTube or the Alchemy's , content related to Hardhat is inevitable. This is not surprising as in the field of Web3 development, Hardhat is undoubtedly one of the most mainstream frameworks. However, I encountered the same pitfall in the process of learning these two courses, that is, after using Hardhat to deploy smart contracts, I could never succeed in the verification. The same error always occurred: video tutorial solidity bootcamp An unexpected error occurred:
ConnectTimeoutError: Connect Timeout Error
...... I searched on Google for a long time but didn't find a complete solution. Then I tried to ask GPT-4 but still failed to solve it. Eventually, I found some insights in this on GitHub. Now, in combination with the actual process of solving this problem myself, I will record the process of analysis and verification, hoping to help those who also encounter this problem. post Firstly, I want to analyze the causes of this problem： I'm using the WSL2 system. The proxy is set in the Windows environment, and the WSL2 system shares the proxy from the Windows environment. Therefore, the solution idea in the aforementioned post did not initially catch my attention. I originally thought that my WSL2 system had set up to share the proxy from the Windows environment, and that I could connect normally using the command, so the inability to use Hardhat's verify function should not be a problem with the proxy settings. curl http://google.com Moreover, my error message and the content in the aforementioned post were quite different, aside from the ConnectTimeoutError. Given that Hardhat itself frequently updates, I thought it was an issue with the Hardhat version or a problem with one of its dependencies. What's more, GPT-4 analyzed the situation in the same way at the time, which somewhat misled my thinking. I tried to upgrade and downgrade and adjust the versions of libraries and dependencies like Hardhat, @nomicfoundation/hardhat-verify, @nomicfoundation/hardhat-toolbox several times, and even tried to apply for multiple API keys on Etherscan, only to find it didn't help. In the end, I realized that although I globally shared the proxy from the Windows environment in WSL2, the verify plugin might not use the global proxy under the WSL2 environment when Hardhat is running due to some reason. Problem Solution and Contract Verification Process Environment configuration: I have a simple here, which deploys an upgradeable contract. You can refer to my package.json file. Many answers online are quite outdated, but my libraries are all up to date. Of particular note is the need to install the Undici library, which will be used to set the proxy for verification. example project Writing the contract and deployment script: This is a standard step and not the focus of this article. But if you are a beginner like me, you can also refer to the simple contract and deployment script in my aforementioned repository. After the writing is done, we can deploy the contract under the Hardhat localhost environment or on the testnet. However, only when deployed on the testnet or mainnet can we use Hardhat's verify plugin. Apply for an API key on the website, which is free. After application, create a new .env file in the root directory of the Hardhat project and paste into it. Then set it in the hardhat.config.js configuration file. You can also refer to the configuration method in this file in my repository. Etherscan ETHERSCAN_KEY=yourApiKey Use the command to view your IP address, assuming it's , then check the "LAN" corresponding HTTP port through the VPN client in your Windows environment, assuming it's yyyyy. Add the following content to your hardhat.config.js file: ip route | grep default | awk '{print $3}' http://xxx.xx.xxx.x const { ProxyAgent, setGlobalDispatcher } = require("undici");
const proxyAgent = new ProxyAgent("http://xxx.xx.xxx.x:yyyyy");
setGlobalDispatcher(proxyAgent); Please note that you should not use the IP address and port in the aforementioned GitHub post, because everyone's VPN client and IP are different. The post also mentioned looking at the DNS server IP using and adding it to the configuration. But if you, like me, share the Windows proxy in the WSL2 environment, then your DNS is likely set by yourself, such as 8.8.8.8. So using the method I mentioned in the fourth point above is the safest. Also, don't forget to turn on options like "Allow LAN connections" in your VPN client. If your client doesn't have this option, you may need to switch to another one. cat /etc/resolv.conf Use the command to verify the contract, or you can write an additional verification function in the deployment script, which will complete the verification immediately after deployment. npx hardhat verify --network yourNetWork CONTRACT_ADDRESS

Solving the ConnectTimeoutError When Verifying Smart Contracts with Hardhat

How to Build a Web3 NFT Cross-Breeding Dapp with React, Solidity, and CometChat

How to Build a Cinema Ticket Booking Dapp with React, Solidity, and CometChat

Quartz is an open-source job scheduling framework that can be integrated into a wide variety of Java applications. It is used to schedule jobs that can be executed at a later time or on a repeating basis. Quartz is designed to be a simple and powerful scheduling framework that is easy to use and configure. But there is no built-in feature in the Quartz framework that allows for the automatic retrying of jobs that encounter exceptions during their execution. This article is inspired by . Here we consider using Quartz in a Spring application and implement an exponential random backoff policy that reduces the number of retry attempts, prevents overloading the system, allows the system to recover slowly over time, and distributes retry attempts evenly. Harvey Delaney’s blog post about Job Exception Retrying in Quartz.NET Storing retry parameters We will use -s that are associated with and objects of our job. ’s will store exponential random backoff policy parameters , , and . JobDataMap associated with Trigger will store . JobDataMap JobDetail Trigger JobDetail JobDataMap MAX_RETRIES RETRY_INITIAL_INTERVAL_SECS RETRY_INTERVAL_MULTIPLIER RETRY_NUMBER Job failure handling listener Now let’s add a Spring component that implements the interface. is called when the job is about to be executed and is called after job completion. In we will increment the counter. will contain the main code of exception handling and creating a new trigger for the next execution of a job. JobFailureHandlingListener org.quartz.JobListener JobListener#jobToBeExecuted JobListener#jobWasExecuted jobToBeExecuted RETRY_NUMBER jobWasExecuted Exponential random backoff policy Exponential random backoff is an algorithm used to progressively introduce delays in retrying an operation that has previously failed. The idea is to increase the delay between retries in an exponential manner, with each delay being chosen randomly from a range of possible values. This helps to avoid the scenario where multiple devices or systems all attempt to retry an operation at the same time, which can further exacerbate the problem that caused the operation to fail in the first place. Exponential random backoff is often used in distributed systems that need to retry operations that have failed. For example, it might be used in a distributed database to retry transactions that fail due to conflicts with other transactions or in a distributed file system to retry operations that fail due to network errors or the temporary unavailability of servers. We will use an exponential random backoff algorithm to calculate the time of the next attempt to start the job. Show me the code JobFailureHandlingListener.java package quartzdemo.listeners;

import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class JobFailureHandlingListener implements JobListener {

    private final String RETRY_NUMBER_KEY = "RETRY_NUMBER";
    private final String MAX_RETRIES_KEY = "MAX_RETRIES";
    private final int DEFAULT_MAX_RETRIES = 5;
    private final String RETRY_INITIAL_INTERVAL_SECS_KEY = "RETRY_INITIAL_INTERVAL_SECS";
    private final int DEFAULT_RETRY_INITIAL_INTERVAL_SECS = 60;
    private final String RETRY_INTERVAL_MULTIPLIER_KEY = "RETRY_INTERVAL_MULTIPLIER";
    private final double DEFAULT_RETRY_INTERVAL_MULTIPLIER = 1.5;

    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public String getName() {
        return "FailJobListener";
    }

    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        context.getTrigger().getJobDataMap().merge(RETRY_NUMBER_KEY, 1,
                (oldValue, initValue) -> ((int) oldValue) + 1);
    }

    @Override
    public void jobExecutionVetoed(JobExecutionContext context) { }

    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        if (context.getTrigger().getNextFireTime() != null || jobException == null) {
            return;
        }
        int maxRetries = (int) context.getJobDetail().getJobDataMap()
                .computeIfAbsent(MAX_RETRIES_KEY, key -> DEFAULT_MAX_RETRIES);
        int timesRetried = (int) context.getTrigger().getJobDataMap().get(RETRY_NUMBER_KEY);
        if (timesRetried > maxRetries) {
            logger.error("Job with ID and class: " + context.getJobDetail().getKey() +", " + context.getJobDetail().getJobClass() +
                    " has run " + maxRetries + " times and has failed each time.", jobException);
            return;
        }

        TriggerKey triggerKey = context.getTrigger().getKey();
        int initialIntervalSecs = (int) context.getJobDetail().getJobDataMap()
                .computeIfAbsent(RETRY_INITIAL_INTERVAL_SECS_KEY, key -> DEFAULT_RETRY_INITIAL_INTERVAL_SECS);
        double multiplier = (double) context.getJobDetail().getJobDataMap()
                .computeIfAbsent(RETRY_INTERVAL_MULTIPLIER_KEY, key -> DEFAULT_RETRY_INTERVAL_MULTIPLIER);
        Date newStartTime = ExponentialRandomBackoffFixtures.getNextStartDate(timesRetried, initialIntervalSecs, multiplier);
        Trigger newTrigger = TriggerBuilder.newTrigger()
                .withIdentity(triggerKey)
                .startAt(newStartTime)
                .usingJobData(context.getTrigger().getJobDataMap())
                .build();
        newTrigger.getJobDataMap().put(RETRY_NUMBER_KEY, timesRetried);

        try {
            context.getScheduler().rescheduleJob(triggerKey, newTrigger);
        } catch (SchedulerException e) {
            throw new RuntimeException(e);
        }
    }

} ExponentialRandomBackoffFixtures.java package quartzdemo.listeners;

import org.apache.commons.lang3.RandomUtils;

import java.time.Duration;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;

public class ExponentialRandomBackoffFixtures {

    public static Date getNextStartDate(int timesRetried, int initialIntervalSecs, double multiplier) {
        double minValue = initialIntervalSecs * Math.pow(multiplier, timesRetried - 1);
        double maxValue = minValue * multiplier;
        Duration duration = Duration.ofMillis((long) (RandomUtils.nextDouble(minValue, maxValue) * 1000));
        LocalDateTime nextDateTime = LocalDateTime.now().plus(duration);
        return Date.from(nextDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

} Now we can add the listener to a scheduler package quartzdemo;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import quartzdemo.listeners.JobFailureHandlingListener;

@Configuration
@EnableScheduling
public class SchedulingConfiguration {

    private final JobFailureHandlingListener jobFailureHandlingListener;

    public SchedulingConfiguration2(JobFailureHandlingListener jobFailureHandlingListener) {
        this.jobFailureHandlingListener = jobFailureHandlingListener;
    }

    @Bean
    public SchedulerFactoryBean scheduler() {
        SchedulerFactoryBean schedulerFactory = new SchedulerFactoryBean();
        // ...
        schedulerFactory.setGlobalJobListeners(jobFailureHandlingListener);
        return schedulerFactory;
    }

} and run a job with a custom parameter RETRY_INITIAL_INTERVAL_SECS package quartzdemo.services;

import org.quartz.*;
import org.springframework.stereotype.Service;
import quartzdemo.jobs.SimpleJob;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;

import static quartzdemo.listeners.JobFailureHandlingListener.RETRY_INITIAL_INTERVAL_SECS_KEY;

@Service
public class SchedulingService {

    private final Scheduler scheduler;

    public SchedulingService(Scheduler scheduler) {
        this.scheduler = scheduler;
    }

    // ...

    private void scheduleJob() throws SchedulerException {
        Date afterFiveSeconds = Date.from(LocalDateTime.now().plusSeconds(5).atZone(ZoneId.systemDefault()).toInstant());

        JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class).usingJobData(RETRY_INITIAL_INTERVAL_SECS_KEY, 30).build();
        Trigger trigger = TriggerBuilder.newTrigger().startAt(afterFiveSeconds).usingJobData("", "").build();
        scheduler.scheduleJob(jobDetail, trigger);
    }
} Conclusion Quartz is a robust framework that provides a wide range of capabilities. Even if it lacks something, it is always possible to implement the necessary functionality using the provided API. This allows developers to extend the framework to meet their specific requirements, so Quartz is a great choice for any scheduling needs.

Stories, News & Mentions about SPGLOBAL

Spglobal’s Stories on HackerNoon

Spglobal's News & Mentions