Get the most recent info and news about Addepar on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Addepar is a software and data platform that is purpose-built for professional wealth, investment and asset management firms to deliver outstanding results for their clients. More than 800 leading firms trust Addepar to unlock the power and possibility of more informed, data-driven investing and advice. With client presence in more than 30 countries, Addepar’s platform aggregates portfolio, market and client data for over $4 trillion in assets. Firms can also use Marketplace, a digital experience offered through Acervus Securities (member FINRA), to access and transact in a range of investment products with a focus on alternative and private market investments. Addepar’s open platform integrates with more than 100 software, data and services partners to deliver a complete solution for a wide range of firms and use cases. Addepar embraces a global flexible workforce model with offices in Silicon Valley, New York City, Salt Lake City, Chicago, London and Edinburgh, Scotland.

Addepar

addepar

Addepar opened a new office in Pune, India in March 2023 as they deepened their commitment to global expansion and R&D investment. Abhimanyu “Abhi” Prabhavalkar recently joined Addepar’s ...

Wealthtech Addepar Appoints Abhimanyu Prabhavalkar as Head of India Operations

Bompey, who recently served as General Counsel and Chief Risk Officer at Addepar, a fintech data platform, brings over 25 years of legal expertise in technology licensing, data management ...

Prove Identity Appoints Mitch Bompey as Chief Legal Officer

Joe Lonsdale, the serial entrepreneur behind such firms as Palantir, Addepar and Opto Investments, spoke with Aaron Klein, Nitrogen (formerly Riskalyze) CEO, at the company's annual conference to ...

Serial Entrepreneur Joe Lonsdale on Breaking Into the RIA Market

Addepar has shared key platform updates, research insights and the latest client, partner and company developments. This month, Addepar is highlighting updates that will “enable firms to run ...

Wealthtech Addepar Introduces Features Allowing Clients to Run Reports at Enterprise Scale

FP caught up with Addepar, Palantir, OpenGov and Opto Investments founder Joe Lonsdale to discuss the shift from the "free money" era of 2021 to the more thoughtful, high-rate environment of fall ...

Addepar, Opto founder Joe Lonsdale on what it takes to stand out in today's wealthtech landscape

London & Capital, the UK-based firm with a focus on serving HNW clients with links to the US, has collaborated with Addepar, the technology and data company for investment professionals. Under terms of the agreement, L&C brings data modelling, portfolio ...

London & Capital Agrees Addepar Deal

Partnership combines London & Capital's global and strategic investment mindset with Addepar's best-in-class technology foundation and data network to power their technology stack LONDON, Sept. 21, 2023 /PRNewswire/ -- London & Capita l, an international ...

London & Capital Partners with Addepar to Deliver Tailored Investment Management and Reporting on a Global Scale

Partnership combines London & Capital's global and strategic investment mindset with Addepar's best-in-class technology foundation and data network to power their technology stack LONDON ...

Data visualization has become an integral part of the IT world today. Small as well as large firms need effective, clear and interactive ways to interpret their business data. To use and gain insights from the data generated by different web technologies, the data should be refined and visualized properly. In fact, if the data is well understood, then it leads to taking well-informed decisions in an organization over time. In web development, visualizing data could be very effective as it helps in creating interactive web pages. At the same time, you will need some tools to implement the same. In this blog, we have discussed top 10 javascript charting libraries for web development which can provide you more better ways to visualize the data. 1) Flot Free License: Flot is one of the oldest charting libraries for web development and mainly focuses on the simple use and interactive features. It is used for jQuery, which means that you need to be familiar with basic jQuery to use it. On the other hand, it allows you to have a full control over the presentation, animation and user interaction. It is compatible with most modern browsers and compatible with previous versions up to IE6. Its plugin repository provides many other types of graphics, all contributed by the community. You can also consult various examples of charts made with Flot here. 2) Morris.js Free License: Morris is a perfect example of good-looking charts which is a lightweight library based on Raphael and jQuery. It provides a clean line, bar, simple area charts, and donut charts. It is one of the definite worth charting libraries for web development if you are looking for easy, quick and classy one. 3) Dygraphs Free License: Dygraphs is an open-source JavaScript library that is best suited to extremely large data sets. It is interactive from the start, with pinch and zoom support even on mobile devices. Moreover, it is compatible with most modern browsers and compatible up to IE8. The options and personalized callbacks make it highly configurable too. 4) Ember Charts Free License: Ember Charts provides an expandable and easy-to-use graphics set built in the D3.js and Ember.js framework. The developers of Addepar have been constantly working to improve the Ember experience with the additional libraries Ember Widgets, Ember Charts, Ember Tables. It is robust and polished which means the handling of errors for incorrect data ensures that your application does not fall if there is strange data. You can even create your own chart types by extending it. 5) Google Charts Free but not open-source License: Google Charts provides a wide range of graphics/charts, for almost any type of data visualization need of your business. The charts are based on VML and HTML5 / SVG for previous versions of IE. All these charts are interactive, and some can also be panned / zoomable. You can take a look at its extensive graphics gallery here. 6) Chartist.js Free License: Chartist provides an easy and intuitive use even for those who feel uncomfortable moving away from Excel sheets. Their graphics are responsive and independent DPI, that means it is a great solution if your graphics are meant to be used on any type of device viz. tablets, mobile devices, or desktop computers. It is based on SVG, which makes it compatible in the future. The best thing about Chartist.js is that it is a community effort, born out of frustration about the limitations provided by other graphics libraries for web development. That’s why they have taken care of various missing features and tweaks which can cause heartburn if you work with other Javascript libraries for web development. 7) Highcharts Free for non-commercial, paid for commercial uses License: Highcharts is one of the popular interactive charting libraries for web development, and like others, it is based on HTML5 / SVG / VML, which means it does not require additional add-ons. It supports a wide range of charts such as maps, spline, column, bar, angular meters, among others.` It provides an interface called Highcharts cloud to create interactive graphics online. Moreover, it is completely free for personal use. You only need to buy a license for commercial use. 8) Sigma.js Free License: Sigma is one of the powerful JavaScript libraries for web development which mainly focused on presenting interactive graphs and networks for the web. Sigma libraries, as well as plugins, include a large number of interactive configurations. Once you’ve used Sigma, you’ll never again think that line charts are boring. So, take a close look at this rollover demo from Sigma.js and you’ll know what I mean. 9) Chart.js Free License: Chart.js is one of the perfect Javascript libraries for web development especially created for small projects, when you need clean, flat and elegant, fast JavaScript tables. It is a small open source library of only 11kb when it is minimized and compressed. This includes 6 types of central graphics naming radar, polar, line, bar, circular and donut), each in its own module, so you can even load only those your project needs, which further reduces your footprint. You can use HTML5 canvas elements to render diagrams and compatibility with polyfills to work in IE7 / 8. 10) FusionCharts Free for non-commercial, paid for commercial uses License: FusionCharts presents one of the most complete JavaScript libraries for web development with more than 90 graphics and 900 maps, all ready to use immediately. They boast of having the best graphics in the industry and backing it with a powerful reporting experience through their panels that help to present the business functions in a bird’s-eye view. They also covered all the bases when it comes to formats like JSON and XML data format, the representation can be done through HTML5 / SVG or VML and the graphics can be exported in PNG, JPG or PDF format. FusionCharts extensions facilitate integration with any technology of your choice, such as PHP, jQuery, AngularJS, and Rails. Moreover, it is compatible across all types of devices and ultimately ensures cross-browser compatibility. Conclusion: So far we have seen the top 10 javascript charting libraries for web development. These have become the most powerful tools to visualize data in the form of beautiful, easy-to-understand interactive graphics. They facilitate the extraction and transmission of key patterns and knowledge that are often not apparent with static graphics and ultimately helps web development companies to create amazing business sites for their clients. By choosing the best tool from the above list, you can grow your business in the right manner. However, if you are finding any difficulty in choosing between the given tools, you can consult us at . ValueCoders is a specializing in custom web development services in , and various other technologies. from us to achieve ValueCoders leading web development company Reactjs , Vuejs Angularjs Hire developers success for your business.

Top 10 JavaScript Charting Libraries For Your Web Development

By , former VP Engineering at Addepar. on . Vladimir Novakovski Originally published Quora I have so far interviewed over a thousand engineers, data scientists, and quants and hired over a hundred within the hedge fund space, Quora, Addepar, and other companies. One thing to keep in mind is that you can’t to be a strong engineer or computer scientist. That comes from experience, education, and natural talent and shouldn’t be done in the context of the pressure of the job market. There’s nothing worse than interviewing someone who just memorized some things a few days earlier and doesn’t really understand them. prepare What you prepare for is the setting of an interview, where you have to think on your feet and generate discussion, answers, and code quickly. Equally important is to talk to industry experts and understand where your skill sets and interests are a good match, in terms of companies and groups. can For the mechanics of the technical interview before you start talking to companies, I’d suggest . They have an excellent set of technical problems that map out to actual questions asked in interviews and a robust platform to solve these problems and get realtime feedback with a low time commitment from your end. Codefights Once you’re ready, you need to understand what particular companies are looking for and how your strengths apply. If you are interested in practice interviews and feedback on how you index on these dimensions, I recommend checking out , a new recruiting platform that connects candidates with established industry veterans for technical interviews and referrals. Full disclosure: I am an advisor to the company. HiDimensional The main benefit in the platform, beyond the personalized feedback interviewers like myself share, is that we write recommendations of candidates who do well and refer those candidates to startups hiring on the platform that match their skill set. It’s an effective way of understanding your strengths and interests and fast-tracking the hiring process with a credible endorsement. By , former VP Engineering at Addepar. on . Vladimir Novakovski Originally published Quora For more trending tech answers from , visit . Quora HackerNoon.com/quora

How the Hiring Manager Wants You To Prepare for a Software Engineering Job Interview

Authors: (1) Maria Rigaki, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and maria.rigaki@fel.cvut.cz; (2) Sebastian Garcia, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and sebastian.garcia@agents.fel.cvut.cz. Table of Links Abstract & Introduction Threat Model Background and Related Work Methodology Experiments Setup Results Discussion Conclusion, Acknowledgments, and References Appendix 8 Conclusions By employing model-based reinforcement learning, MEME generates adversarial malware samples that successfully evade antivirus systems and train a surrogate model mimicking the target classifier accurately. Our experiments show that MEME surpasses existing methods in evasion rate, suggesting its potential for various applications, such as testing model robustness and enhancing cyber security against advanced persistent threats. Future work may involve exploring ensemble surrogates and other optimizations to enhance MEME’s performance further. Acknowledgments The authors acknowledge support from the Strategic Support for the Development of Security Research in the Czech Republic 2019–2025 (IMPAKT 1) program, by the Ministry of the Interior of the Czech Republic under No. VJ02010020 – AI-Dojo: Multi-agent testbed for the research and testing of AI-driven cyber security technologies. The authors acknowledge the support of NVIDIA Corporation with the donation of a Titan V GPU used for this research. References 1. Akiba, T., Sano, S., Yanase, T., Ohta, T., Koyama, M.: Optuna: A Next-generation Hyperparameter Optimization Framework. In: Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining. pp. 2623–2631. KDD ’19, Association for Computing Machinery, New York, NY, USA (Jul 2019). https://doi.org/10.1145/3292500.3330701 2. Anderson, H.S., Kharkar, A., Filar, B., Evans, D., Roth, P.: Learning to Evade Static PE Machine Learning Malware Models via Reinforcement Learning (Jan 2018). https://doi.org/10.48550/arXiv.1801.08917, arXiv:1801.08917 [cs] 3. Anderson, H.S., Roth, P.: EMBER: An Open Dataset for Training Static PE Malware Machine Learning Models (Apr 2018). https://doi.org/10.48550/arXiv.1804.04637, arXiv:1804.04637 [cs] 4. Bergstra, J., Bardenet, R., Bengio, Y., K´egl, B.: Algorithms for Hyper-Parameter Optimization. In: Advances in Neural Information Processing Systems. vol. 24. Curran Associates, Inc. (2011) 5. Brockman, G., Cheung, V., Pettersson, L., Schneider, J., Schulman, J., Tang, J., Zaremba, W.: OpenAI Gym (Jun 2016). https://doi.org/10.48550/arXiv.1606.01540, arXiv:1606.01540 [cs] 6. Ceschin, F., Botacin, M., Gomes, H.M., Oliveira, L.S., Gr´egio, A.: Shallow Security: on the Creation of Adversarial Variants to Evade Machine Learning-Based Malware Detectors. In: Proceedings of the 3rd Reversing and Offensive-oriented Trends Symposium. pp. 1–9. ROOTS’19, Association for Computing Machinery, New York, NY, USA (Feb 2020). https://doi.org/10.1145/3375894.3375898 7. Chandrasekaran, V., Chaudhuri, K., Giacomelli, I., Jha, S., Yan, S.: Exploring connections between active learning and model extraction. In: Proceedings of the 29th USENIX Conference on Security Symposium. pp. 1309–1326. SEC’20, USENIX Association, USA (Aug 2020) 8. Correia-Silva, J.R., Berriel, R.F., Badue, C., de Souza, A.F., Oliveira-Santos, T.: Copycat CNN: Stealing Knowledge by Persuading Confession with Random Non-Labeled Data. In: 2018 International Joint Conference on Neural Networks (IJCNN). pp. 1–8 (Jul 2018). https://doi.org/10.1109/IJCNN.2018.8489592, iSSN: 2161-4407 9. Demetrio, L., Biggio, B., Lagorio, G., Roli, F., Armando, A.: FunctionalityPreserving Black-Box Optimization of Adversarial Windows Malware. IEEE Transactions on Information Forensics and Security 16, 3469–3478 (2021). https://doi.org/10.1109/TIFS.2021.3082330, conference Name: IEEE Transactions on Information Forensics and Security 10. Demetrio, L., Coull, S.E., Biggio, B., Lagorio, G., Armando, A., Roli, F.: Adversarial exemples: A survey and experimental evaluation of practical attacks on machine learning for windows malware detection. ACM Transactions on Privacy and Security (TOPS) 24(4), 1–31 (2021), publisher: ACM New York, NY, USA 11. Dowling, S., Schukat, M., Barrett, E.: Using Reinforcement Learning to Conceal Honeypot Functionality. In: Brefeld, U., Curry, E., Daly, E., MacNamee, B., Marascu, A., Pinelli, F., Berlingerio, M., Hurley, N. (eds.) Machine Learning and Knowledge Discovery in Databases. pp. 341–355. Lecture Notes in Computer Science, Springer International Publishing, Cham (2019). https://doi.org/10.1007/978-3-030-10997-4 21 12. Fang, Y., Zeng, Y., Li, B., Liu, L., Zhang, L.: DeepDetectNet vs RLAttackNet: An adversarial method to improve deep learning-based static malware detection model. PLOS ONE 15(4), e0231626 (Apr 2020). https://doi.org/10.1371/journal.pone.0231626, publisher: Public Library of Science 13. Fang, Z., Wang, J., Geng, J., Kan, X.: Feature Selection for Malware Detection Based on Reinforcement Learning. IEEE Access 7, 176177–176187 (2019). https://doi.org/10.1109/ACCESS.2019.2957429, conference Name: IEEE Access 14. Fang, Z., Wang, J., Li, B., Wu, S., Zhou, Y., Huang, H.: Evading Anti-Malware Engines With Deep Reinforcement Learning. IEEE Access 7, 48867–48879 (2019). https://doi.org/10.1109/ACCESS.2019.2908033, conference Name: IEEE Access 15. Harang, R., Rudd, E.M.: SOREL-20M: A Large Scale Benchmark Dataset for Malicious PE Detection. arXiv:2012.07634 [cs] (Dec 2020), arXiv: 2012.07634 16. Hu, W., Tan, Y.: Generating Adversarial Malware Examples for Black-Box Attacks Based on GAN. In: Tan, Y., Shi, Y. (eds.) Data Mining and Big Data. pp. 409–423. Communications in Computer and Information Science, Springer Nature, Singapore (2022). https://doi.org/10.1007/978-981-19-8991-9 29 17. Huang, L., Zhu, Q.: Adaptive Honeypot Engagement Through Reinforcement Learning of Semi Markov Decision Processes. In: Alpcan, T., Vorobeychik, Y., Baras, J.S., D´an, G. (eds.) Decision and Game Theory for Security. pp. 196– 216. Lecture Notes in Computer Science, Springer International Publishing, Cham (2019). https://doi.org/10.1007/978-3-030-32430-8 13 18. Institute, A.T.: AV-ATLAS - Malware & PUA (2023), https://portal.av-atlas.org/malware 19. Jagielski, M., Carlini, N., Berthelot, D., Kurakin, A., Papernot, N.: High Accuracy and High Fidelity Extraction of Neural Networks. pp. 1345–1362 (2020) 20. Ke, G., Meng, Q., Finley, T., Wang, T., Chen, W., Ma, W., Ye, Q., Liu, T.Y.: LightGBM: A Highly Efficient Gradient Boosting Decision Tree. In: Advances in Neural Information Processing Systems. vol. 30. Curran Associates, Inc. (2017) 21. Kurutach, T., Clavera, I., Duan, Y., Tamar, A., Abbeel, P.: Model-Ensemble TrustRegion Policy Optimization. In: International Conference on Learning Representations (2018) 22. Labaca-Castro, R., Franz, S., Rodosek, G.D.: AIMED-RL: Exploring Adversarial Malware Examples with Reinforcement Learning. In: Dong, Y., Kourtellis, N., Hammer, B., Lozano, J.A. (eds.) Machine Learning and Knowledge Discovery in Databases. Applied Data Science Track. pp. 37–52. Lecture Notes in Computer Science, Springer International Publishing, Cham (2021). https://doi.org/10.1007/978-3-030-86514-6 3 23. Li, X., Li, Q.: An IRL-based malware adversarial generation method to evade anti-malware engines. Computers & Security 104, 102118 (May 2021). https://doi.org/10.1016/j.cose.2020.102118 24. Ling, X., Wu, L., Zhang, J., Qu, Z., Deng, W., Chen, X., Qian, Y., Wu, C., Ji, S., Luo, T., Wu, J., Wu, Y.: Adversarial attacks against Windows PE malware detection: A survey of the state-of-the-art. Computers & Security 128, 103134 (May 2023). https://doi.org/10.1016/j.cose.2023.103134 25. Lundberg, S.M., Lee, S.I.: A Unified Approach to Interpreting Model Predictions. In: Advances in Neural Information Processing Systems. vol. 30. Curran Associates, Inc. (2017) 26. Nguyen, T.T., Reddi, V.J.: Deep Reinforcement Learning for Cyber Security. IEEE Transactions on Neural Networks and Learning Systems pp. 1–17 (2021). https://doi.org/10.1109/TNNLS.2021.3121870, conference Name: IEEE Transactions on Neural Networks and Learning Systems 27. Orekondy, T., Schiele, B., Fritz, M.: Knockoff Nets: Stealing Functionality of BlackBox Models. pp. 4954–4963 (2019) 28. Pal, S., Gupta, Y., Shukla, A., Kanade, A., Shevade, S., Ganapathy, V.: ActiveThief: Model Extraction Using Active Learning and Unannotated Public Data. Proceedings of the AAAI Conference on Artificial Intelligence 34(01), 865–872 (Apr 2020). https://doi.org/10.1609/aaai.v34i01.5432, number: 01 29. Phan, T.D., Duc Luong, T., Hoang Quoc An, N., Nguyen Huu, Q., Nghi, H.K., Pham, V.H.: Leveraging Reinforcement Learning and Generative Adversarial Networks to Craft Mutants of Windows Malware against Black-box Malware Detectors. In: Proceedings of the 11th International Symposium on Information and Communication Technology. pp. 31–38. SoICT ’22, Association for Computing Machinery, New York, NY, USA (Dec 2022) 30. Quertier, T., Marais, B., Morucci, S., Fournel, B.: MERLIN – Malware Evasion with Reinforcement LearnINg (Mar 2022), arXiv:2203.12980 [cs] 31. Raffin, A., Hill, A., Gleave, A., Kanervisto, A., Ernestus, M., Dormann, N.: StableBaselines3: Reliable Reinforcement Learning Implementations. Journal of Machine Learning Research 22(268), 1–8 (2021) 32. Rigaki, M., Garcia, S.: Stealing and evading malware classifiers and antivirus at low false positive conditions. Computers & Security 129, 103192 (Jun 2023). https://doi.org/10.1016/j.cose.2023.103192 33. Rosenberg, I., Meir, S., Berrebi, J., Gordon, I., Sicard, G., Omid David, E.: Generating End-to-End Adversarial Examples for Malware Classifiers Using Explainability. In: 2020 International Joint Conference on Neural Networks (IJCNN). pp. 1–10 (Jul 2020). https://doi.org/10.1109/IJCNN48605.2020.9207168, iSSN: 2161-4407 34. Sanyal, S., Addepalli, S., Babu, R.V.: Towards Data-Free Model Stealing in a Hard Label Setting. pp. 15284–15293 (2022) 35. Schulman, J., Wolski, F., Dhariwal, P., Radford, A., Klimov, O.: Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347 (2017) 36. Security.org, T.: 2023 Antivirus Market Annual Report (Feb 2023), https://www.security.org/antivirus/antivirus-consumer-report-annual/ 37. Severi, G., Meyer, J., Coull, S., Oprea, A.: Explanation-Guided Backdoor Poisoning Attacks Against Malware Classifiers. In: 30th USENIX Security Symposium (USENIX Security 21). pp. 1487–1504. USENIX Association (2021) 38. Song, W., Li, X., Afroz, S., Garg, D., Kuznetsov, D., Yin, H.: MAB-Malware: A Reinforcement Learning Framework for Blackbox Generation of Adversarial Malware. In: Proceedings of the 2022 ACM on Asia Conference on Computer and Communications Security. pp. 990–1003. ASIA CCS ’22, Association for Computing Machinery, New York, NY, USA (May 2022). https://doi.org/10.1145/3488932.3497768 39. Sussman, B.: New Malware Is Born Every Minute (May 2023), https://blogs.blackberry.com/en/2023/05/new-malware-born-every-minute 40. Sutton, R.S., Barto, A.G.: Reinforcement Learning, second edition: An Introduction. MIT Press (Nov 2018) 41. Total, V.: VirusTotal - Stats, https://www.virustotal.com/gui/stats 42. Uprety, A., Rawat, D.B.: Reinforcement Learning for IoT Security: A Comprehensive Survey. IEEE Internet of Things Journal 8(11), 8693–8706 (Jun 2021). https://doi.org/10.1109/JIOT.2020.3040957, conference Name: IEEE Internet of Things Journal 43. Wu, C., Shi, J., Yang, Y., Li, W.: Enhancing Machine Learning Based Malware Detection Model by Reinforcement Learning. In: Proceedings of the 8th International Conference on Communication and Network Security. pp. 74–78. ICCNS 2018, Association for Computing Machinery, New York, NY, USA (Nov 2018). https://doi.org/10.1145/3290480.3290494 44. Zolotukhin, M., Kumar, S., H¨am¨al¨ainen, T.: Reinforcement Learning for Attack Mitigation in SDN-enabled Networks. In: 2020 6th IEEE Conference on Network Softwarization (NetSoft). pp. 282–286 (Jun 2020). https://doi.org/10.1109/NetSoft48620.2020.9165383 45. Sembera, V., Paquet-Clouston, M., Garcia, S., Erquiaga, M.J.: Cybercrime Spe- ˇ cialization: An Expos´e of a Malicious Android Obfuscation-as-a-Service. In: 2021 IEEE European Symposium on Security and Privacy Workshops (EuroS&PW. pp. 213–236 (2021). https://doi.org/10.1109/EuroSPW54576.2021.00029 This paper is under CC BY-NC-SA 4.0 DEED license. available on arxiv

Enhancing Cybersecurity with MEME: Reinforcement Learning for Adversarial Malware Evasion

Creating a Wordle with TDD in Javascript

Welcome to other chapters of Let’s Understand Chrome V8 Dispatch is responsible for scheduling bytecode, which is equivalent to registering EIP++, and jumps to the next bytecode. Dispatch consists of two parts, one is a dispatch table and the other is the physical register. The table is an array that contains all bytecode addresses. V8 uses the physical register to dispatch bytecode for getting greater efficiency. 1. Dispatch Table The dispatch table is an array of pointers, which is used to store the address of the bytecode processing program. The array type is Code, and the Code Class is below: class Code: public HeapObject {
    public: NEVER_READ_ONLY_SPACE
    using Flags = uint32_t;
    #define CODE_KIND_LIST(V)\
    V(OPTIMIZED_FUNCTION)\
    V(BYTECODE_HANDLER)\
    V(STUB)\
    V(BUILTIN)\
    V(REGEXP)\
    V(WASM_FUNCTION)\
    V(WASM_TO_CAPI_FUNCTION)\
    V(WASM_TO_JS_FUNCTION)\
    V(JS_TO_WASM_FUNCTION)\
    V(JS_TO_JS_FUNCTION)\
    V(WASM_INTERPRETER_ENTRY)\
    V(C_WASM_ENTRY)
    enum Kind {
      #define DEFINE_CODE_KIND_ENUM(name) name,
        CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
      #undef DEFINE_CODE_KIND_ENUM
      NUMBER_OF_KINDS
    };
    static
    const char * Kind2String(Kind kind);
    #ifdef ENABLE_DISASSEMBLER
    const char * GetName(Isolate * isolate) const;
    V8_EXPORT_PRIVATE void Disassemble(const char * name, std::ostream & os,
      Address current_pc = kNullAddress);
    #endif
    //................omit................
  }; : In the isolate, there is another pointer array that is the same type as the dispatch table. It holds all the Builtins addresses, which can confuse beginners easily. Note The dispatch table is maintained by BuildWithMacroAssembler, code is below: Code BuildWithMacroAssembler(Isolate * isolate, int32_t builtin_index,
    MacroAssemblerGenerator generator,
    const char * s_name) {
    HandleScope scope(isolate);
    // Canonicalize handles, so that we can share constant pool entries pointing
    // to code targets without dereferencing their handles.
    CanonicalHandleScope canonical(isolate);
    constexpr int kBufferSize = 32 * KB;
    byte buffer[kBufferSize];
    MacroAssembler masm(isolate, BuiltinAssemblerOptions(isolate, builtin_index),
      CodeObjectRequired::kYes,
      ExternalAssemblerBuffer(buffer, kBufferSize));
    masm.set_builtin_index(builtin_index);
    DCHECK(!masm.has_frame());
    generator( & masm);
    int handler_table_offset = 0;
    // JSEntry builtins are a special case and need to generate a handler table.
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSEntry), Builtins::ASM);
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSConstructEntry), Builtins::ASM);
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSRunMicrotasksEntry), Builtins::ASM);
    if (Builtins::IsJSEntryVariant(builtin_index)) {
      handler_table_offset = HandlerTable::EmitReturnTableStart( & masm);
      HandlerTable::EmitReturnEntry( &
        masm, 0, isolate -> builtins() -> js_entry_handler_offset());
    }
    //.....................................................
    //................omit.............................
  } You can see regarding how to debug the BuildWithMacroAssembler. When the value of the parameter builtin_index is 65, the function pointer generator points to which is responsible for maintaining the Dispatch table, code is below: Chapter 9 Generate_InterpreterEnterBytecodeDispatch static void Generate_InterpreterEnterBytecode(MacroAssembler * masm) {
    // Set the return address to the correct point in the interpreter entry
    // trampoline.
    Label builtin_trampoline, trampoline_loaded;
    Smi interpreter_entry_return_pc_offset(
      masm -> isolate() -> heap() -> interpreter_entry_return_pc_offset());
    DCHECK_NE(interpreter_entry_return_pc_offset, Smi::kZero);
    // If the SFI function_data is an InterpreterData, the function will have a
    // custom copy of the interpreter entry trampoline for profiling. If so,
    // get the custom trampoline, otherwise grab the entry address of the global
    // trampoline.
    __ movq(rbx, Operand(rbp, StandardFrameConstants::kFunctionOffset));
    __ LoadTaggedPointerField(
      rbx, FieldOperand(rbx, JSFunction::kSharedFunctionInfoOffset));
    __ LoadTaggedPointerField(
      rbx, FieldOperand(rbx, SharedFunctionInfo::kFunctionDataOffset));
    __ CmpObjectType(rbx, INTERPRETER_DATA_TYPE, kScratchRegister);
    __ j(not_equal, & builtin_trampoline, Label::kNear);
    __ movq(rbx,
      FieldOperand(rbx, InterpreterData::kInterpreterTrampolineOffset));
    __ addq(rbx, Immediate(Code::kHeaderSize - kHeapObjectTag));
    __ jmp( & trampoline_loaded, Label::kNear);
    __ bind( & builtin_trampoline);
    // TODO(jgruber): Replace this by a lookup in the builtin entry table.
    __ movq(rbx,
      __ ExternalReferenceAsOperand(
        ExternalReference::
        address_of_interpreter_entry_trampoline_instruction_start(
          masm -> isolate()),
        kScratchRegister));
    __ bind( & trampoline_loaded);
    __ addq(rbx, Immediate(interpreter_entry_return_pc_offset.value()));
    __ Push(rbx);
    // Initialize dispatch table register.
    __ Move(
      kInterpreterDispatchTableRegister,
      ExternalReference::interpreter_dispatch_table_address(masm -> isolate()));
    // Get the bytecode array pointer from the frame.
    __ movq(kInterpreterBytecodeArrayRegister,
      Operand(rbp, InterpreterFrameConstants::kBytecodeArrayFromFp));
    if (FLAG_debug_code) {
      // Check function data field is actually a BytecodeArray object.
      __ AssertNotSmi(kInterpreterBytecodeArrayRegister);
      __ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE,
        rbx);
      __ Assert(
        equal,
        AbortReason::kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry);
    }
    // Get the target bytecode offset from the frame.
    __ movq(kInterpreterBytecodeOffsetRegister,
      Operand(rbp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
    __ SmiUntag(kInterpreterBytecodeOffsetRegister,
      kInterpreterBytecodeOffsetRegister);
    // Dispatch to the target bytecode.
    __ movzxbq(r11, Operand(kInterpreterBytecodeArrayRegister,
      kInterpreterBytecodeOffsetRegister, times_1, 0));
    __ movq(kJavaScriptCallCodeStartRegister,
      Operand(kInterpreterDispatchTableRegister, r11,
        times_system_pointer_size, 0));
    __ jmp(kJavaScriptCallCodeStartRegister);
  }
  //================================separation=========================
  void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler * masm) {
    Generate_InterpreterEnterBytecode(masm);
  } In the above code, the is the entry point of bytecode dispatch, and the is the key code that implements the bytecode dispatch. Here are two important concepts: Generate_InterpreterEnterBytecodeDispatch Generate_InterpreterEnterBytecode The is a Builtin and its index is 65. (The index may be dissimilar in different V8 versions) Generate_InterpreterEnterBytecodeDispatch V8 uses a physical register to manage the dispatch table, the name of the register is . Using the physical register can avoid the push and pop of the dispatch table frequently, to improve efficiency. kInterpreterDispatchTableRegister Here are the key lines of code： Line 35, loads the dispatch table to the A register. Line 37 of code, take out the table address from the isolate. The implementation of A is in the below three functions. (1) ExternalReference ExternalReference::interpreter_dispatch_table_address(
  Isolate * isolate) {
  return ExternalReference(isolate -> interpreter() -> dispatch_table_address());
}
interpreter::Interpreter * interpreter() const {
  return interpreter_;
}
Address dispatch_table_address() {
  return reinterpret_cast < Address > ( & dispatch_table_[0]);
} Line 39 takes out the bytecode array from the stack. (2) Line 51 takes out the offset of the target bytecode from the bytecode array. (3) Lines 56 and 58 calculate the target bytecode address and store the address in kJavaScriptCallCodeStartRegister. (4) Line 61 jumps to register kJavaScriptCallCodeStartRegister and executes bytecode. Figure 1 is the call stack. (5) 2. TailCall The Dispatch() is the last step in a bytecode, so its alias is the tail call. Let’s look at a few bytecodes： IGNITION_HANDLER(StaGlobal, InterpreterAssembler) {
    TNode < Context > context = GetContext();
    //omit..............
    Goto( & end);
    Bind( & no_feedback);
    CallRuntime(Runtime::kStoreGlobalICNoFeedback_Miss, context, value, name);
    Goto( & end);
    Bind( & end);
    Dispatch(); // !!! this is the tail call.
  }
  IGNITION_HANDLER(LdaContextSlot, InterpreterAssembler) {
    TNode < Context > context = CAST(LoadRegisterAtOperandIndex(0));
    TNode < IntPtrT > slot_index = Signed(BytecodeOperandIdx(1));
    TNode < Uint32T > depth = BytecodeOperandUImm(2);
    TNode < Context > slot_context = GetContextAtDepth(context, depth);
    TNode < Object > result = LoadContextElement(slot_context, slot_index);
    SetAccumulator(result);
    Dispatch(); //!!! here also is.
  }
  IGNITION_HANDLER(LdaImmutableContextSlot, InterpreterAssembler) {
    TNode < Context > context = CAST(LoadRegisterAtOperandIndex(0));
    TNode < IntPtrT > slot_index = Signed(BytecodeOperandIdx(1));
    TNode < Uint32T > depth = BytecodeOperandUImm(2);
    TNode < Context > slot_context = GetContextAtDepth(context, depth);
    TNode < Object > result = LoadContextElement(slot_context, slot_index);
    SetAccumulator(result);
    Dispatch(); //!!! here 
  } The above three bytecodes all end with Dispatch(). Below is the code of Dispatch: void InterpreterAssembler::Dispatch() {
    Comment("========= Dispatch");
    DCHECK_IMPLIES(Bytecodes::MakesCallAlongCriticalPath(bytecode_), made_call_);
    TNode < IntPtrT > target_offset = Advance();
    TNode < WordT > target_bytecode = LoadBytecode(target_offset);
    if (Bytecodes::IsStarLookahead(bytecode_, operand_scale_)) {
      target_bytecode = StarDispatchLookahead(target_bytecode);
    }
    DispatchToBytecode(target_bytecode, BytecodeOffset());
  } The 2nd line is the comment function. When debugging, we can use its output information to locate the execution position. The 4th line takes out the offset of the target(next) bytecode. The 5th line loads the target bytecode. The 9th line calls which calls eventually. DspatchToBytecode() DispatchToBytecodeHandlerEntry() void InterpreterAssembler::DispatchToBytecodeHandlerEntry(
  TNode < RawPtrT > handler_entry, TNode < IntPtrT > bytecode_offset) {
  // Propagate speculation poisoning.
  TNode < RawPtrT > poisoned_handler_entry =
    UncheckedCast < RawPtrT > (WordPoisonOnSpeculation(handler_entry));
  TailCallBytecodeDispatch(InterpreterDispatchDescriptor {},
    poisoned_handler_entry, GetAccumulatorUnchecked(),
    bytecode_offset, BytecodeArrayTaggedPointer(),
    DispatchTablePointer());
} In , parameter 1 is the target bytecode and 2 is the offset of the bytecode. Parameter 1 is used to load the bytecode handler and 2 is used to load operands. Then call , which is below: DispatchToBytecodeHandlerEntry TailCallBytecodeDispatch template < class...TArgs >
    void CodeAssembler::TailCallBytecodeDispatch(
      const CallInterfaceDescriptor & descriptor, TNode < RawPtrT > target,
        TArgs...args) {
      DCHECK_EQ(descriptor.GetParameterCount(), sizeof...(args));
      auto call_descriptor = Linkage::GetBytecodeDispatchCallDescriptor(
        zone(), descriptor, descriptor.GetStackParameterCount());
      Node * nodes[] = {
        target,
        args...
      };
      CHECK_EQ(descriptor.GetParameterCount() + 1, arraysize(nodes));
      raw_assembler() -> TailCallN(call_descriptor, arraysize(nodes), nodes);
    } In the above code, the 5th line creates the descriptor, as below: CallDescriptor * Linkage::GetBytecodeDispatchCallDescriptor(
    Zone * zone,
    const CallInterfaceDescriptor & descriptor,
      int stack_parameter_count) {
    const int register_parameter_count = descriptor.GetRegisterParameterCount();
    const int parameter_count = register_parameter_count + stack_parameter_count;
    DCHECK_EQ(descriptor.GetReturnCount(), 1);
    LocationSignature::Builder locations(zone, 1, parameter_count);
    locations.AddReturn(regloc(kReturnRegister0, descriptor.GetReturnType(0)));
    for (int i = 0; i < parameter_count; i++) {
      if (i < register_parameter_count) {
        // The first parameters go in registers.
        Register reg = descriptor.GetRegisterParameter(i);
        MachineType type = descriptor.GetParameterType(i);
        locations.AddParam(regloc(reg, type));
      } else {
        int stack_slot = i - register_parameter_count - stack_parameter_count;
        locations.AddParam(LinkageLocation::ForCallerFrameSlot(
          stack_slot, MachineType::AnyTagged()));
      }
    }
    MachineType target_type = MachineType::Pointer();
    LinkageLocation target_loc = LinkageLocation::ForAnyRegister(target_type);
    const CallDescriptor::Flags kFlags =
      CallDescriptor::kCanUseRoots | CallDescriptor::kFixedTargetRegister;
    return new(zone) CallDescriptor( // --
      CallDescriptor::kCallAddress, // kind
      target_type, // target MachineType
      target_loc, // target location
      locations.Build(), // location_sig
      stack_parameter_count, // stack_parameter_count
      Operator::kNoProperties, // properties
      kNoCalleeSaved, // callee-saved registers
      kNoCalleeSaved, // callee-saved fp
      kFlags, // flags
      descriptor.DebugName());
  } In , parameter 2 is the target bytecode, and parameter 3 is the stack parameter count. This function is used to apply for register resources and create a . The gives what parameters to supply when executing a bytecode. The comments on lines 24 to 25 give its layout. GetBytecodeDispatchCallDescriptor CallDescriptor CallDescriptor In , the on the 9th line is below, we see that it’s parameter 1 is . TailCallBytecodeDispatch TailCallN() CallDescriptor void RawMachineAssembler::TailCallN(CallDescriptor * call_descriptor,
    int input_count, Node *
    const * inputs) {
    // +1 is for target.
    DCHECK_EQ(input_count, call_descriptor -> ParameterCount() + 1);
    Node * tail_call =
      MakeNode(common() -> TailCall(call_descriptor), input_count, inputs);
    schedule() -> AddTailCall(CurrentBlock(), tail_call);
    current_block_ = nullptr;
  } The 5th line generates a node. In the 7th line adds the node to the end of the current basic block. So far, the dispatch is completed and the next bytecode is started to execute. Figure 2 shows the function call stack. AddTailCall() Okay, that wraps it up for this share. I’ll see you guys next time, take care! Please reach out to me if you have any issues. : qq9123013 : v8blink@outlook.com WeChat Email Also published . here

Let's Understand Chrome V8 — Chapter 11: Bytecode Dispatch 

Everybody is playing Wordle these days... And I love . TDD So, here I will explain how to develop a wordle game using TDD in just 25 minutes. TL;DR: With just a few steps we can build a robust Wordle. Defining a word The minimum information amount in Wordle is a word. We can argue that is smaller, but we think all needed letter protocol is already defined (we might be wrong). letter A word is not a string. This is a common mistake and a . bijection violation A and a have different responsibilities, though they might intersect. word string Mixing (accidental) implementation details with (essential) behavior is a very common mistake. So we need to define . what is a word A word in Wordle is a 5 letter word. valid Let's start with our happy path: <?php

namespace Wordle;

use PHPUnit\Framework\TestCase;

final class WordTest extends TestCase {
    public function test01ValidWordLettersAreValid() {
        $wordleWord = new Word('valid');
        $this->assertEquals(['v', 'a', 'l', 'i', 'd'], $wordleWord->letters());
    }
} We assert that prompting for letters in 'valid' returns an array with the letters. Notice Word class is not defined yet. We don't care about letter sorting. That would be a premature optimization and gold plating scenario. We start with a simple example. No duplicated. We don't mess with word validation yet (word might be XXXXX). We can start with a simpler test just validation word is created. This would violate the test structure that always requires an assertion. Expected value should always be first. We get an error: Error : Class "Wordle\Word" not found This is good in TDD, We are exploring our domain. We need to create a Word with the constructor and the letters() function. <?php

Namespace Wordle;

final class Word {

    function __construct(string $letters) {
    }

    function letters(): array {
        return ['v', 'a', 'l', 'i', 'd'];
    }
} Notice We don't need anything to do with the constructor parameter. We hardcode letters function since this is the simplest possible solution up to now.
-- Fake it till we make it. Classes are final to avoid subclassification. We run all the tests (just 1) and we are OK. OK (1 test, 1 assertion) Let's write another test: <?php 

  public function test02FewWordLettersShouldRaiseException() {
        $this->expectException(\Exception::class);
        new Word('vali');
  } Notice PHPUnit exception raising is not very good. We just declare an exception will be raised. Test fails... Failed asserting that exception of type "Wordle\Exception" is thrown. We need to change our implementation in order to make test02 pass (and also test01) <?php 

  public function test02FewWordLettersShouldRaiseException() {
        $this->expectException(\Exception::class);
        new Word('vali');
  } Notice We just check for a few letters. not for too many since we don't have yet a covering test. TDD requires full coverage. Adding another check without a test is a technique violation. We just raise a generic Exception. Creating special exceptions is a that pollutes namespaces. (unless we catch it, but this is not happening right now). code smell Let's check for too many <?php 
  public function test03TooManyWordLettersShouldRaiseException() {
        $this->expectException(\Exception::class);
        new Word('toolong');
  } The test fails as expected. Let's correct it. Failed asserting that exception of type "Exception" is thrown. <?php

function __construct(string $letters) {
        if (strlen($letters) < 5)
            throw new \Exception('Too few letters. Should be 5');
        if (strlen($letters) > 5)
            throw new \Exception('Too many letters. Should be 5');
} And all tests passed. OK (3 tests, 3 assertions) We can now make an (optional) refactor and change the function to assert for a range instead of two boundaries. We decide to leave this way since it is more declarative. We can also add a test checking for zero words following the . Zombie methodology Let's do it. <?php

  public function test04EmptyLettersShouldRaiseException() {
        $this->expectException(\Exception::class);
        $wordleWord = new Word('');
  } It is no surprise test passes since we already have a test covering this scenario. As this test adds no value we should remove it. Let's check now what is a valid letter: <?php

  public function test05InvalidLettersShouldRaiseException() {
        $this->expectException(\Exception::class);
        $wordleWord = new Word('vali*');
  } ... and the test is broken since no assertion is raised. Failed asserting that exception of type "Exception" is thrown. We need to correct the code... <?php

  function __construct(string $letters) {
       if (str_contains($letters,'*')) {
          throw new \Exception('word contain invalid letters');
  } And all tests pass since we are clearly hardcoding. OK (5 tests, 5 assertions) Let's add more invalid letters and correct the code. <?php

  public function test06PointShouldRaiseException() {
        $this->expectException(\Exception::class);
        $wordleWord = new Word('v.lid');
  }

  //Solution

  function __construct(string $letters) {
        if (str_contains($letters, '.'))
            throw new \Exception('word contain invalid letters');
    ///....
  } Notice We didn't write a more generic function (yet) since we cannot correct tests and refactor at the same time (the technique forbids us). All tests are ok. We can refactor. We replace the last two sentences <?php

  function __construct(string $letters) {
        if (!\preg_match('/^[a-z]+$/i', $letters)) {
            throw new \Exception('word contain invalid letters');
      }
    //.. Notice The assertion checks only for uppercase letters. Since we are dealing with these examples up to now. We defer design decisions as much as possible. We defined a regular expression based on English Letters. We are pretty sure it won't accept Spanish (ñ), German(ë), etc. As a checkpoint, we have only five letters words from now on. Le't’s assert on letters() function. We left it hardcoded. TDD Opens many paths. We need to keep track of all of them until we open new ones. We need to compare words <?php  

  public function test07TwoWordsAreNotTheSame() {
        $firstWord = new Word('valid');
        $secondWord = new Word('happy');
        $this->assertNotEquals($firstWord, $secondWord);
  }

  public function test08TwoWordsAreTheSame() {
        $firstWord = new Word('valid');
        $secondWord = new Word('valid');
        $this->assertEquals($firstWord, $secondWord);
    } And test fails. Let's use the parameter we are sending to them. <?php

final class Word {

    private $setters;
    function __construct(string $letters) {
        if (!\preg_match('/^[a-z]+$/i', $letters)) {
            throw new \Exception('word contain invalid letters');
        }
        if (strlen($letters) < 5) {
            throw new \Exception('Too few letters. Should be 5');
        }
        if (strlen($letters) > 5) {
            throw new \Exception('Too many letters. Should be 5');
        }
        $this->letters = $letters;
    }

    function letters(): array {
        return ['v', 'a', 'l', 'i', 'd'];
    }
} Notice We store the letters and this is enough for objects comparison (it might depend on the language). letters() function is still hardcoded Tests are OK OK (8 tests, 8 assertions) We add a different word for letters comparison <?php

public function test09LettersForGrassWord() {
        $grassWord = new Word('grass');
        $this->assertEquals(['g', 'r', 'a', 's', 's'], $grassWord->letters());
    } And test fails. Failed asserting that two arrays are equal. It is very important to check for equality/inequality instead of assertTrue() since many IDEs open a comparison tool based on the objects. This is another reason to use IDEs and never text editors. Let's change the letters() function <?php 

  function letters(): array {
        return str_split($this->letters);
  } Our words are in a bijection with English Wordle words. or not? <?php

  public function test10XXXXIsnotAValidWord() {
        $this->expectException(\Exception::class);
        $wordleWord = new Word('xxxxx');
  } This test fails. We are not catching invalid English 5 letter words. We need to make a decision. According to our bijection, there's an external dictionary asserting for valid words. We can validate with the dictionary upon word creation. But we want the dictionary to store valid wordle words. Not strings. It is an egg-chicken problem. We decide to deal with invalid words in the dictionary and not the Wordle word. We create new tests on our dictionary. <?php

namespace Wordle;

use PHPUnit\Framework\TestCase;

final class DictionaryTest extends TestCase {
    public function test01EmptyDictionaryHasNoWords() {
        $dictionary = new Dictionary([]);
        $this->assertEquals(0, $dictionary->wordsCount());
    }
} The test fails since we have not defined our Dictionary. We do it: <?php

Namespace Wordle;

final class Dictionary {

    function __construct(array $words) {
        $this->words = $words;
    }

    function wordsCount(): int {
        return 0;
    }
} Notice We don't do anything with the words yet. We hardcode the number of words. We faked it yet again. We add another case for count 1 if the dictionary has one word. <?php
  public function test02SingleDictionaryReturns1AsCount() {
        $words = [new Word('happy')];
        $dictionary = new Dictionary($words);
        $this->assertEquals(1, $dictionary->wordsCount());
   } Test fails as expected Failed asserting that 0 matches expected 1. We correct it. <?php

final class Dictionary {

    private $words;
    function __construct(array $words) {
        $this->words = $words;
    }

    function wordsCount(): int {
        return count($this->words);
    }
} Notice Dictionary is immutable No Setters or getters We start with inclusion and get an error. Error : Call to undefined method Wordle\Dictionary::includesWord() So we fake it. <?php
public function test03DictionaryDoesNotIncludeWord() {
        $words = [new Word('happy')];
        $dictionary = new Dictionary($words);
        $this->assertFalse($dictionary->includesWord(new Word('sadly')));
    }

 
//the solution
function includesWord(): bool {
        return false;
    } We add a positive case.
And we need to correct the function instead of hardcoding it. <?php 

public function test04DictionaryIncludesWord() {
        $words = [new Word('happy')];
        $dictionary = new Dictionary($words);
        $this->assertTrue($dictionary->includesWord(new Word('happy')));
    }

function includesWord(Word $subjectToSearch): bool {
        return in_array($subjectToSearch, $this->words);
    } We have the dictionary working. Let's create the game. <?php

final class GameTest extends TestCase {
    public function test01EmptyGameHasNoWinner() {
        $game = new Game();
        $this->assertFalse($game->hasWon());
    }
} Test fails.
We need to create the class and the function. <?php

Namespace Wordle;

final class Game {

    function __construct() {
    }

    function hasWon(): bool{
        return false;
    }

} We implement words tried.
And the simplest solution <?php

public function test02EmptyGameHasNoWinner() {
        $game = new Game();
        $this->assertEquals([], $game->wordsTried());
    }

//and the model

function wordsTried(): array {
        return [];
    } Let's try some words.
We get Error : Call to undefined method Wordle\Game::addtry() We define it. <?php

public function test03TryOneWordAndRecordIt() {
        $game = new Game();
        $game->addtry(new Word('loser'));
        $this->assertEquals([new Word('loser')], $game->wordsTried());
    }

//The solution

final class Game {

    private $wordsTried;
    function __construct() {
        $this->wordsTried = [];
    }

    function addTry(Word $trial) {
        return $this->wordsTried[] = $trial;
    }

    function wordsTried(): array {
        return $this->wordsTried;
    }
} Notice We store the trials locally and add the trial and also change wordsTried() real implementation. We can implement hasLost() if it misses 5 trials.
With the simplest implementation as usual. <?php

public function test04TryOneWordAndDontLooseYet() {
        $game = new Game();
        $game->addtry(new Word('loser'));
        $this->assertFalse($game->hasLost());
    }

//the solution
 function hasLost(): bool {
        return false;
    } As always. I stop faking it and decide to make it. Failed asserting that false is true. So we change it as below. <?php
  public function test05TryFiveWordsLoses() {
        $game = new Game();
        $game->addtry(new Word('loser'));
        $game->addtry(new Word('loser'));
        $game->addtry(new Word('loser'));
        $game->addtry(new Word('loser'));
        $this->assertFalse($game->hasLost());
        $game->addtry(new Word('loser'));
        $this->assertTrue($game->hasLost());
    }
'''

//The code
function hasLost(): bool {
        return count($this->wordsTried) > 4;
    } We have most of the mechanics. Let's add the dictionary and play invalid. <?php

    public function test06TryToPlayInvalid() {
        $words = [new Word('happy')];
        $dictionary = new Dictionary($words);
        $game = new Game($dictionary);
        $this->expectException(\Exception::class);
        $game->addtry(new Word('xxxx'));
    } We need to pass the dictionary to fix the tests <?php

final class Game {

    private $wordsTried;
    private $dictionary;
    function __construct(Dictionary $validWords) {
        $this->dictionary = $validWords;
        $this->wordsTried = [];
    }

    function addTry(Word $trial) {
        if (!$this->dictionary->includesWord($trial)){
            throw new \Exception('Word is not included ' . $trial);
        }
        return $this->wordsTried[] = $trial;
    }
} Fixed. Now, we play to win <?php
  public function test07GuessesWord() {
        $words = [new Word('happy')];
        $dictionary = new Dictionary($words);
        $winnerWord = new Word('happy');
        $game = new Game($dictionary, $winnerWord);
        $this->assertFalse($game->hasWon());
        $game->addtry(new Word('happy'));
        $this->assertTrue($game->hasWon());
    } We need to correct . hasWon() <?php

  private $winnerWord;
    function __construct(Dictionary $validWords, Word $winnerWord) {
        $this->dictionary = $validWords;
        $this->wordsTried = [];
        $this->winnerWord = $winnerWord;
    }

    function hasWon(): bool {
        return in_array($this->winnerWord, $this->wordsTried);
    } Notice We use no flags to check if someone has won. We can directly check it. We make an refactor with this new element to previous game definitions. addParameter We added winnerWord.
We need to assert this word is in the dictionary. <?php 
 public function test08WinnerWordNotInDictionary() {
        $words = [new Word('happy')];
        $dictionary = new Dictionary($words);
        $winnerWord = new Word('heros');
        $this->expectException(\Exception::class);
        $game = new Game($dictionary, $winnerWord);
    }
 
//and add the check...

function __construct(Dictionary $validWords, Word $winnerWord) {
        if (!$validWords->includesWord($winnerWord)){
            throw new \Exception('Winner word must be in dictionary');
        } OK (8 tests, 10 assertions) We have all the mechanics. Let's add the letter's positions.
We can do it in Word class. <?php
public function test10NoMatch() {
        $firstWord = new Word('trees');
        $secondWord = new Word('valid');
        $this->assertEquals([], $firstWord->matchesPositionWith($secondWord));
    }


//This method in Word class

 function matchesPositionWith(Word $anotherWord) : array {
        return [];
    } Test passes OK (10 tests, 10 assertions) Let's match <?php
  public function test11MatchesFirstLetter() {
        $firstWord = new Word('trees');
        $secondWord = new Word('table');
        $this->assertEquals([1], $firstWord->matchesPositionWith($secondWord));
    } Fails. We need to define it better <?php
function matchesPositionWith(Word $anotherWord) : array {
        $positions = [];
        for ($currentPosition = 0; $currentPosition < count($this->letters()); $currentPosition++){
            if ($this->letters()[$currentPosition] == $anotherWord->letters()[$currentPosition]) {
                $positions[] = $currentPosition + 1; //Humans start counting on 1
                //We can implement this better in several other languages
            }
        }
        return $positions;
    } We keep running all the tests all the time OK (23 tests, 25 assertions) We can add a safety test to be more declarative <?php

public function test12MatchesAllLetters() {
        $firstWord = new Word('trees');
        $secondWord = new Word('trees');
        $this->assertEquals([1, 2, 3 , 4 ,5], $firstWord->matchesPositionWith($secondWord));
    } Now we need the final steps. Matching in incorrect positions.
and always the simplest solution... <?php
public function test13MatchesIncorrectPositions() {
        $firstWord = new Word('trees');
        $secondWord = new Word('drama');
        $this->assertEquals([2], $firstWord->matchesPositionWith($secondWord));
        $this->assertEquals([], $firstWord->matchesIncorrectPositionWith($secondWord));
    }

//the easy solution
function matchesIncorrectPositionWith(Word $anotherWord) : array {
        return [];
    } A more spicy test case.
Let's go for the implementation <?php
public function test14MatchesIncorrectPositionsWithMatch() {
        $firstWord = new Word('alarm');
        $secondWord = new Word('drama');
        $this->assertEquals([3], $firstWord->matchesPositionWith($secondWord));
        $this->assertEquals([1, 4, 5], $firstWord->matchesIncorrectPositionWith($secondWord));
        //A*ARM vs *RAMA
        $this->assertEquals([3], $secondWord->matchesPositionWith($firstWord));
        $this->assertEquals([2, 4, 5], $secondWord->matchesIncorrectPositionWith($firstWord));
    }

// The complicated solution

function matchesIncorrectPositionWith(Word $anotherWord) : array {
        $positions = [];
        //count($this->letters() is always 5 but we don't want to add a magic number here
        for ($currentPosition = 0; $currentPosition < count($this->letters()); $currentPosition++){
            if (in_array($this->letters()[$currentPosition], $anotherWord->letters())) {
                $positions[] = $currentPosition + 1; //Humans start counting on 1
                //We can implement this better in several other languages
            }
        }
        return array_values(array_diff($positions, $this->matchesPositionWith($anotherWord)));
    } We remove from the occurrences the exact matches. OK (26 tests, 32 assertions) That's it. We have implemented a very small model with all meaningful rules. Future Steps A good model should endure requirements change. In the following articles, we will make these enhancements also using TDD: Manage different languages and characters. Import the words from a text file. Add a Visual Engine and host it. Implement an Absurdle Develop a machine-learning algorithm to minimize wordle moves. Repository You can have all the code (and make pull requests on ) GitHub https://github.com/mcsee/TDD-Wordle Conclusion TDD is an iterative methodology. If you find some missing functionality you can write me on and we will add it (after a failing test case, of course). twitter Hope you like this article and enjoy playing Wordle!

Building a Wordle Game Using Test-Driven Development in 25 Minutes

In this article I’ll show how fast to develop React / Redux app using . Redux Lazy Let me share links to my previous articles about : Redux Lazy _Each time working with redux in react app we spend a lot of time to make action types, action creators, reducers… Most…_hackernoon.com React — redux for lazy developers _In this article I’m continue to discuss creating react redux app using redux-lazy._hackernoon.com React — redux for lazy developers. Part 2 _It’s the last part of series about creating react redux app._hackernoon.com React — redux for lazy developers. Part 3 is a wrapper for redux stuff (action types, action creators, reducers, containers…). It’s like recompose for redux. Redux Lazy If you are working with you know that it’s a package of useful high order components (HOC). But before using created HOCs by other developers you should know how to create a simple React component, how to compose it with other components and how to create own HOC. recompose The same with Redux Lazy. It’s not a new store library. It’s just a wrapper, with a little bit magic (yes, I know that magic in code is not a good practice) you can save up to 50% of time on creating React / Redux app. Before start describing Redux Lazy I want to show the main parts of working with Redux. Redux is a store. You can read a lot of manuals and articles with documentation or good practices. But store is always a store. It’s a place where you can save your data. For redux to get data you should create selectors (like SQL SELECT) for react-redux connect HOC and action types, action creators and reducers to set data using store dispatch. So I’ll show each point of working with redux here: Action types: NAME_SPACE_TEXT = '@@nameSpace/TEXT'; export const Here I just created one action type. It should help with storing text field to store. Name space I use to split a big app into small modules with own components, store (using combineReducers) and logic (I use ). redux-observable Action creator: { NAME_SPACE_TEXT } './types'; import from textAction = text => ({type: NAME_SPACE_TEXT,text,}); export const Reducer: { NAME_SPACE_TEXT } './types'; import from defaultState = {text: '',}; const (state = defaultState, action) => { (action.type) { NAME_SPACE_TEXT: { ...state, ...action }; : state;}}; export default switch case return default return This is a simple reducer. The main idea is just check action type and if it’s our text action, create a new state using previous state with action. Container: { connect } 'react-redux'; as actions './actions'; import from import * from mapStateToProps = state => state[NAME_SPACE]; mapDispatchToProps = { ...actions }; const const connect(mapStateToProps, mapDispatchToProps); export default Here I use the same name space to get part of store in my module. helps me to wrap my action creators with store dispatch function. mapDispatchToProps I need to add reducer to store: { combineReducers } 'redux'; nameSpace './reducer'; import from import from rootReducer = combineReducers({... ,}); const nameSpace And wrap component by the container: import Container from './container';import Component from './component'; Container(Component); export default That’s all. Each time to make a new feature you should create types, creators, reducers, containers… instead of thinking about your app logic. To save my time I created Redux Lazy. It can make all this stuff for your. You need to describe which actions do you need and get it. So let me introduce Redux Lazy. To use it you should make some small steps. First step is installing redux-lazy: npm i -S redux-lazy Or with yarn: yarn add redux-lazy The second step is creating creating Redux Lazy model: RL 'redux-lazy'; import from rl = RL('modelName'); const new const {nameSpace,types,actions,defaultState,reducer,mapStateToProps,mapDispatchToProps,Container,} = rl. (); flush Here we should set a name space of our model. For example I use name space. modelName And it creates nameSpace, types, actions, reducer, container… for you. Next you should think which fields in store do you need. Imagine that you are working with SQL table. You need to have name for it (than’s why I use name space) and fields. modelName For example, from the previous example, we need only one field — . So your job is making getter and setter for this field. text addEventAction(name) If you need to send event to redux-observable you need to create action type with only one field: . And epics can run some jobs for you. type RL 'redux-lazy'; import from rl = RL('modelName'); const new rl.addEventAction('event'); { types, actions } = rl. (); const flush { MODEL_NAME_EVENT } = types; { eventAction } = actions; const const { MODEL_NAME_EVENT, eventAction }; export rl; export default eventAction() // => { : MODEL_NAME_EVENT } type eventAction(anyData) // => { : MODEL_NAME_EVENT } type addFormAction(name); If you need to submit form with redux actions you need to work with events and put function into form component. There is a good practice to use links instead of objects or functions inside a components. Because it always creates a new instances and React should render again component even if data is the same. <form onSubmit={(event) => {event.preventDefault();props.submitAction();}}> With Redux Lazy you can avoid useless rendering: rl.addFormAction('submit'); <form onSubmit={ }> props.submitAction addFormElementAction(name, defaultValue) The same for form elements. Each time you should get value from event (event.target.value): <inputtype="text"onChange={ }value={props.title}/> event => props.titleAction(event.target.value) With Redux Lazy you can make it much easy: rl.addFormElementAction('title', ''); <inputtype="text"onChange={ }value={props.title}/> props.titleAction addParamAction(name, defaultValue) It’s the same like addFormElementAction but with simple data instead of event object. It’s totally the same like any redux action creator: rl.addParamAction('title', 'defaultValue'); { actions } = rl. (); { titleAction } = actions; const flush const titleAction('data')// => {type: '@@modelName/TITLE', title: 'data'} titleAction()// => {type: '@@modelName/TITLE', title:'defaultValue'} addParamsAction(name, payload) If you need to set more than one field you can use addParam Action: s rl.addParamsAction('clear', { title: '', body: '' }); { actions } = rl. (); { clearAction } = actions; const flush const clearAction('1', '2') // => { title: '1', body: '2' } clearAction('1') // => { title: '1', body: ''} clearAction() // => { title: '', body: '' } Redux Lazy really helps me to speed up my React / Redux development. But some times it’s hard to get all actions, types… I know how it works and what I can get from . But first time maybe you can run and see what types, actions, nameSpace… are inside. rl.flush() console.log(rl) I think it’s not a great payment for development speed. You can see more . examples Please ask your questions in comments and don’t forget to star it on . github

React/Redux development on steroids

I. People love and hate End-to-End testing and for valid reasons. I’ve seen many projects (including my own) get fascinated with automated End-to-End testing and gradually come to a point where the test cases become flaky, slow and totally ignored. Let’s see why and how to make E2E testing both a good developer experience and a solid firewall for software regressions. For the purpose of the demo, we will be testing a which is a recruitment platform for HR agencies. By the end of the article we are going to have these test cases implemented: React\Node.js application User can sign up User can login User can post a job ad User can see a candidate appear on a job board Use Cypress.io For quite a while there is been one major player in the field of E2E web application testing — selenium. Most of the solutions out there were basically building their APIs on top of selenium, so they all suffered from the same problem that selenium has. Cypress.io is a new player that has no selenium dependency and is set to address the shortcoming of its predecessor. Let’s see what Cypress API can look like with our test cases. describe('Smoke tests', () => {  it('User can sign up', () => {    cy      .signup()      .get('body').contains('Create Your First Job');    });   it('user can login', () => {    cy      .login()      .get('body').contains('Create Your First Job')  });}); OK, there is no magical signup() or login() methods, but there is a nice API for extending the ‘ ’ global with custom methods: cy Cypress.addParentCommand("login", (email, password) => {    cy      .visit('/')      .get('form input[name="email"]').clear().type(email)      .get('form input[name="password"]').clear().type(password)      .get('form button').click()  });   Cypress.addParentCommand("signup", (name, email, password) => {    cy      .visit('/')      .get('body').contains('Sign Up').click()      .submitSignupForm(name, email)      .followLinkFromEmail()      .submitProfileForm(name, email)      .get('body').contains('Create Your Company')      .submitCompanyForm()      .get('body').contains('Add Team Members')      .get('button').contains('Skip').click()      .get('body').contains('Create Your First Job')  }); Design initial state for every test case If we are to make the testing fast, we will need to start every test case from a predefined state of the application. Let’s define the initial states for every test case: . We don’t really need any user-related data in the database. Though there can be some read-only data present to support the application. Let’s call it “ ” state. “User can sign up” empty and “ ” both suggest that user has already undergone the signup flow, so the minimal initial state is — “ ” “User can login” User can post a job ad signed-up And finally needs a job to be present, hence “ ” state. “User can see a candidate appear on a job board” job-posted So, let’s update our test cases to explicitly define the states: describe('Smoke tests', () => {  it('User can sign up', () => {    cy      .state('empty')      .signup()      .get('body').contains('Create Your First Job');    });   it('user can login', () => {    cy      .state('signed-up')      .login()      .get('body').contains('Create Your First Job')  });}); The state function makes an XHR request to the API that resets its state to some predefined state. Cypress.addParentCommand("state", (...states) => {  cy    .request({      url: `${Cypress.env('BASE_API')}/integration/state`,      method: 'POST',      headers: { 'content-type': 'application/json' },      body: JSON.stringify({ states: states })    });}); We do need some support code to assist in setting the state, but the effort involved pays off in performance and maintainability of your tests. On the backend we are using MongoDB native, so the code in question can look like this: const stateLoaders = {  'empty': require('./states/empty'),  'signed-up': require('./states/signed-up'),  ...}; export const loadState = async (db, states = ['empty']) => {  await clean(db);   for (let state of states) { //many states? well sometimes you need to test complex One can argue why have many states when you can have one big state for all cases. The answer is maintainability and performance. First, you save a lot of time on not loading the data that you don’t need. But what’s more important is maintainability. You application state that you are going to need for testing may conflict with each other. For example, you want to test a case where user submitted a sign-up form but did not verify his email, so you will need a special user for that, and now we have 2 users in your database and you will have to differentiate between them in your tests. You will quickly notice that the amount of data in your state is hard to reason about. Whereas if you choose to run test case against a minimal possible state, it is easy to track state changes. II. In the first part of this article we looked at how using Сypress and choosing the right mocking strategy helped us write End-to-End tests that are both performant, reliable and easy to work with. To get the feeling of the snappiness check out this video that Cypress recorded for us during the test run. In this part, we will focus on another practical aspect of E2E testing — running tests on CI. Use docker-compose With E2E testing, we want to bring in as many parties (micro-services, APIs, transport) of the application as possible, so that we can ensure the best coverage and integration. Ideally, we should be testing a production clone, but that comes with a substantial overhead for performance — we don’t want to waste time and resources on deployment for every single build. What we want is to give a fast feedback to a developer if his commits introduced regressions or not. Here comes Docker. Docker-compose gives you this ability to declaratively bring all micro-services that your application needs together, run them on CI along with your tests. Let’s assemble our application for testing in one nice docker-compose.yml file. For the demo we are still using this typical React/Node.js app consisting of 4 images here: frontend — is the react app with a server that serves static files API — is the Node.js API MongoDB — persistence Cypress — is our test runner that will open frontend image URL in the browser, but can also send requests to API to reset the state of the application #docker-compose.ymlversion: '2'services: cypress:   build:     context: .     dockerfile: Dockerfile.cypress   links:     - frontend     - api   command: /app/wait-for-it.sh frontend:3000 -t 60 -- npm run test frontend:   environment:     - NODE_ENV=integration   build:     context: .     dockerfile: Dockerfile.frontend   ports:     - 3000:3000   expose:     - 3000   links:     - api   command: /app/wait-for-it.sh api:4000 -t 60 -- npm run start api:   environment:     - NODE_ENV=integration   image: 'noviopus/api-dev:latest'   ports:     - 4000:4000   expose:     - 4000   links:     - mongodb mongodb:   image: mongo:3.2 . Some notable things to note here Firstly, we are using the latest version of the API image here. The main idea is that API is developed and deployed in a backward-compatible way in regards to the frontend, so when a new version of API comes out, we know that all our deployed frontend will continue to work (within the specific environments). This allows us to evolve application without resorting to versioning of the builds. Secondly, we are explicitly waiting for image’s dependencies to be ready to accept connections using this simple yet useful so that we know that all services are ready before we run the first test. script Here is what Circle CI 2.0 configuration file look like with Docker-compose: version: 2jobs: build:   docker:     #run all commands in this image:     - image: dziamid/ubuntu-docker-compose #ubuntu + docker + docker-compose     - checkout     - setup_remote_docker     - run:         #need to login so we can pull private repos from hub in the following runs         name: Login          command: docker login -u $DOCKERHUB_USER -e $DOCKERHUB_EMAIL -p $DOCKERHUB_PASSWORD     - run:         name: Build         command: docker-compose -p app build     - run:         name: Test         command: docker-compose -p app run cypress     - run:         name: Collect artifacts         command: |           docker cp app_cypress_run_1:/app/cypress/artifacts $(pwd)/cypress/artifacts         when: always #execute this run command on success or failure of previous run     - store_test_results:	#expose test results so you can see failing tests on the top of the page         path: cypress/artifacts         when: always     - store_artifacts:	#expose video and screenshots from cypress         path: cypress/artifacts         when: always     - run:         name: Deploy         command: |	# deployment is out of scope of this article Running ` ` shows the glory of Docker-compose. This command will: docker-compose -p app -f bundle.yml run cypress start Cypress image and attach to its output find all dependencies of the Cypress image and start them in the background when the process in Cypress image will exit, it will gracefully terminate all the processes in the background after all the processes terminate, you can access By exposing tests results you will see the summary of your tests on top of the page. In the result, we have integrated E2E into the development workflow. Now we can evolve our micro-services and be confident that they can integrate with each other and the most critical application flows are working as expected. Written by Dziamid Zayankouski Want to learn more? Check out here

Cypress.io & Docker: the Ultimate E2E Stack

Building a 3D Starfield effect on the canvas in Javascript We’ll be building this hyperspace star effect I had a few requests to show how to build on the Math.sin() and Math.cos() examples from the previous article, to do something similar in 3D. But before we can get there, let’s get the basics covered in faking 3D. Creating fake 3D on the canvas is pretty easy once you know how it works. We’ll start small and build on the tricks we learn. The basic trick is to scale our objects to simulate the z-axis view, we use a field of view angle, which is simple the width of the angle of view. The wider the angle, the more 3D distortion you get. And the formula is: scale = FOV/(z+FOV); So let’s make a simple starfield to start… Using our normal particle system code, we also need to give each particle a z-value, a z-speed, a scale value and a 3D x-value and a 3D y-value. We don’t need a x-speed or a y-speed as we’ll just be moving our particles forward. function addParticle(){var particle = {x: random(-100,100),y: random(-100,100), }particles.push(particle);} z: 10,x3d: 0,y3d: 0,scale: 1,speed_z: 4 We’ll then calculate our 3D positions, based on our formula. Note we subtract our z-position to move the balls forward and use our scale to calculate our new 3D x and y-positions: function moveParticles(){ for (var i = 0; i < particles.length; i++) {var p = particles[i]; p.z -= p.speed_z;p.scale = fov/(p.z+FOV);p.x3d = p.x * p.scale;p.y3d = p.y * p.scale; } } And you should be getting something like this: So one thing you’ll notice is the particles eventually start moving backwards. Easy enough to fix, just check if they’ve reached past their negative FOV, remove them. And the only other thing is to add a semi transparent background to get a trail effect. The full code, to get the effect on the article header, will look like this: var ctx = createCanvas("canvas1");var particles = [];var FOV = 250; function addParticle(){var particle = {x: random(-100,100),y: random(-100,100),z: 10,x3d: 0,y3d: 0,speed_z: 2,scale: 1,colour: rgb(0),}particles.push(particle);} function draw(){ctx.background(0, 0.2);addParticle();moveParticles();drawParticles();} function moveParticles(){for (var i = 0; i < particles.length; i++) {var p = particles[i];p.z -= p.speed_z;p.scale = FOV/(p.z+FOV);p.x3d = p.x * p.scale;p.y3d = p.y * p.scale; if (p.z < -FOV) {  
  particles.splice(i,1);  
} }} function drawParticles(){ctx.save();ctx.translate(w/2, h/2);for (var i = 0; i < particles.length; i++) {var p = particles[i];ctx.fillStyle = rgb(255);ctx.fillEllipse(p.x3d, p.y3d, p.scale, p.scale);}ctx.restore();} And that’s it. We’re done. Happy . coding As usual the full code is available on my , this article is part 9 (be sure to do a pull every now and then, because I’m updating things often): github https://github.com/GeorgeGally/creative_coding Follow me on Instagram here: https://www.instagram.com/radarboy3000/ Follow me on Twitter here: https://twitter.com/radarboy_japan And like my Facebook Page here: https://www.facebook.com/radarboy3000

Faking 3D in creative coding

Welcome to the next installment of Creative Coding Basics. You can see previous tutorials . here This time I’m going to take you through a handy bit of algebra that creative coders use all the time: Sine and Cosine — in Javascript and . Math.sin() Math.cos() All the code and libraries for these tutorials can be found here: https://github.com/GeorgeGally/creative_coding If you’ve been following along, do a new git pull to get the latest code. Sine wave osciallation Let’s start with Sine waves which are great to build oscillators. will always oscillate between the values of -1, 1. We multiply this by an amplitude variable to get an oscillating wave effect. Instead of adding speed_x to change our particle’s x-value, we increment an angle variable and pass it through Math.sin() Math.sin() like so: var ctx = createCanvas("canvas1"); var ball = {x: 0,y: h/2,speed_x: random(1),speed_y: random(1),size: random(10, 50),colour: rgb(0),angle: random(360)} function draw(){ctx.background(255);ball.angle += ball.speed_x;ball.rotation += 2;ball.x = w/2 + Math.cos(radians(ball.angle))*w/2;ctx.fillStyle = ball.colour;ctx.fillEllipse(ball.x, ball.y, ball.size);} To get the sine wave effect from this tutorial’s header, we use our usual particle code and oscillate our balls’ y position (ie. move it up and down) while moving the ball left and right: var ctx = createCanvas("canvas1");var number_of_balls = 10;var balls = [];var radius = 200;ctx.lineWidth = 1;ctx.background(0); // push a ball and it's values into the arrayfor (var i = 0; i < number_of_balls; i++) {addBall(i);} function addBall(i){var ball = {x: random(w),y: random(h),speed_x: random(1,4),speed_y: random(1,4), size: 2,colour: rgba(255, 0.8), }balls.push(ball);} amplitude: random(h/10,h/4), angle_x: random(360),angle_y: random(360) function draw(){moveBall();drawBall();} function moveBall(){ for (var i = 0; i < balls.length; i++) {var b = balls[i];b.angle_x += b.speed_x;b.angle_y += b.speed_y;// move } b.x = w/2 + Math.sin(radians(b.angle_x/5)) * w/2; b.y = h/2 + Math.sin(radians(b. )) * b.amplitude; angle_y } function drawBall(){for (var i = 0; i < balls.length; i++) {var b = balls[i];ctx.fillStyle = b.colour;ctx.fillEllipse(b.x, b.y, b.size);}} By oscillating the ball’s x value as well, we can create some interesting effects like this: Change the ball’s x-speed and to get some interesting effects The most common thing I use Math.sin() and Math.cos() for is to draw things in circles… It’s pretty simple. Using our same particles code, we just create an angle variable for the particle and then use to get the x position and to get the y position. We multiply this by our radius and walaa… we have circular movement… Math.cos(angle) Math.sin(angle) var ctx = createCanvas("canvas1");var number_of_balls = 5;var balls = []; // radius of our circle var radius = 200; for (var i = 0; i < number_of_balls; i++) {addBall();} function addBall(){var ball = {x: 0,y: 0, size: random(10, 50),colour: rgb(0), }balls.push(ball);} speed: random(1), angle: random(360) function draw(){ ctx.background(245, 1);moveBall();drawBall();} function moveBall(){ for (var i = 0; i < balls.length; i++) {var b = balls[i]; } // move the angle to rotate the balls b.angle += b.speed; // plot the balls x to cos and y to sin b.x = w/2 + Math.cos(radians(b.angle))*radius;b.y = h/2 + Math.sin(radians(b.angle))*radius; } function drawBall(){for (var i = 0; i < balls.length; i++) {var b = balls[i];ctx.fillStyle = b.colour;ctx.fillEllipse(b.x, b.y, b.size);}} Ok, we have circular movement, now let’s get the balls moving on a circle… Pretty easy, we simply change our function and draw an ellipse twice the size of the radius: draw() function draw(){ctx.background(245, 1);ctx.fillStyle = "black"; moveBall();drawBall();} ctx.HfillEllipse(w/2, h/2, radius*2); Notice I’m using a new ellipse drawing function I’ve made, is exactly the same as fillEllipse(), it’s just a higher resolution version, meaning, we get smoother edges. I usually use this for larger circles to make them look better, but be warned, don’t use it for everything or you’ll have performance issues. HfillEllipse(), this And then we’ll also need to alter our function to take into account the individual ball’s size, so that the balls are rolling on the circle… pretty simple to do, we just add half the ball’s size to the radius: moveBalls() function moveBall(){ for (var i = 0; i < balls.length; i++) {var b = balls[i];// move the angle to rotate the ballsb.angle += b.speed; } b.x = w/2 + Math.cos(radians(b.angle))*(radius+b.size/2);b.y = h/2 + Math.sin(radians(b.angle))*(radius+b.size/2); } And boom, we have this… Balls on a ball! Say, we wanted to distribute the balls evenly on the circle… we could just use a formula like so: ball_number/total_number_of_balls * 360; I’ve made a function for this: function distributeAngles(me, total) {return me/total * 360;} Creative coding, is often, just a combination of simple concepts, to make something slightly more complicated. We now have all the tools we need to create something a little more complicated like this: We have two sets of particles, and out and an inner set. I’ve put these in objects called inners and outers. Note I’ve added an empty array called particles to each object — so we can store our particle var ctx = createCanvas("canvas1"); // create two objectsvar inners = {count: 3,radius: 220,speed: random(2)/100, }; particles: [] var outers = {count: 3,radius: 100,speed: random(-2)/100, }; particles: [] And now we can add our particle values. Notice I pass the whole object into the addParticle() function, which makes it easy to access it’s values. We then work out the angle values of the particles using the same method as we did above. Note we don’t really need to work out the x and y values as we’ll do this on each loop iteration later: for (var i = 0; i < outers.count; i++) { } addParticle(i, outers); for (var i = 0; i < inners.count; i++) { } addParticle(i, inners); // pass in the objectfunction addParticle(_i, _object){ var _angle = radians(distributeAngles(i, _object.count)); var particle = {x: 0,y: 0,speed: _object.speed,angle: _angle,radius: _object.radius} _object.particles.push(particle); } Ok, here comes the final part of the puzzle. Notice that each inner particle is connected to every outer particle. So we loop through all the inner particles for each iteration of the outer particles, like so: // draw and move particles for (var i=0; i< outers.count; i++) { // move the outer particles for (var j=0; j< inners.count; j++) {// move inner particle// then connect it to the outer particle} } So let’s put it all in a function. Note that we add canvas.width/2 to the x values and canvas.height/2 to the y values. We then draw a line from the inner particle to the outer one: function drawLines(){ for (var i=0; i< outers.count; i++) { var outer = outers.particles[i]; outer.angle += outer.speed;outer.x = w/2 + Math.cos(outer.angle) * outer.radius;outer.y = h/2 + Math.sin(outer.angle) * outer.radius; for (var j=0; j< inners.count; j++) {  
  var inner = inners.particles\[j\];  
  **inner.angle += inner.speed;  
  inner.x = w/2 + Math.cos(inner.angle) \* inner.radius;  
  inner.y = h/2 + Math.sin(inner.angle) \* inner.radius;  
  ctx.line(inner.x, inner.y, outer.x, outer.y);**  
} } } And that’s it. We’re done. Happy coding. As usual the full code is available on my github: https://github.com/GeorgeGally/creative_coding Follow me on Instagram here: https://www.instagram.com/radarboy3000/ Follow me on Twitter here: https://twitter.com/radarboy_japan And like my Facebook Page here: https://www.facebook.com/radarboy3000

Math.sin and Math.cos — The creative coder’s best friend

Dapper is an open-source ORM tool that is easy to use and lightweight, which makes it a popular choice for .NET developers. It is designed to work with various databases, including SQL Server, Oracle, MySQL, and PostgreSQL. Dapper is fast and efficient because it does not add any overhead to the data access layer and is very easy to start. Prerequisites Before getting started, you must have basic knowledge of the following. Basic knowledge of C# programming language Docker ORM More about Dapper ORM Wars: Dapper vs EF Core The Battle Continues medium.com Maximizing C# Database Performance with Dapper Dapper is a popular open-source micro-ORM (Object Relational Mapping) framework developed by Stack Overflow. It… medium.com Getting Started This article will discuss the best practices for using Dapper in your C# applications. These practices will help you to write cleaner, more maintainable, and more performant code when working with databases. Use Parameterized Queries: One of the most important best practices when working with databases is to use parameterized queries. Parameterized queries allow you to separate the SQL code from user input, preventing malicious information from being executed as part of the SQL query. Using parameterized queries is easy with Dapper, and it is a best practice that should always be followed. Here is an example of a parameterized query using Dapper: connection.Query<Employee>("SELECT * FROM Employees WHERE EmployeeId = @EmployeeId", new { EmployeeId = 1 }); Use Asynchronous Methods: Dapper supports asynchronous operations, which can improve the performance of your application. Instead of waiting for the database query to complete synchronously, you can use the async/await keywords to execute the query asynchronously. This can help to free up resources and improve the overall responsiveness of your application. Here is an example of using asynchronous methods with Dapper: await connection.QueryAsync<Employee>("SELECT * FROM Employees"); Use the Repository Pattern The Repository pattern is a well-known design pattern separating data access and business logic. Using the Repository pattern with Dapper can help you to organize your code and make it more maintainable. The Repository pattern also makes it easier to test your code, as you can create mock repositories for testing purposes. Here is an example of using the Repository pattern with Dapper: public interface IEmployeeRepository
{
    Employee GetById(int id);
    IEnumerable<Employee> GetAll();
}

public class EmployeeRepository : IEmployeeRepository
{
    private readonly IDbConnection _db;
    public EmployeeRepository(IDbConnection db)
    {
        _db = db;
    }
    public Employee GetById(int id)
    {
        return _db.QuerySingleOrDefault<Employee>("SELECT * FROM Employees WHERE EmployeeId = @EmployeeId", new { EmployeeId = id });
    }
    public IEnumerable<Employee> GetAll()
    {
        return _db.Query<Employee>("SELECT * FROM Employees");
    }
} Use Transactions: Transactions are essential when you're dealing with data that needs to be consistent. Dapper allows you to use transactions, which can help you maintain your data's integrity. Transactions also make it easier to roll back changes if something goes wrong. Here is an example of using transactions with Dapper: using (var transaction = connection.BeginTransaction())
{
    try
    {
        connection.Execute("INSERT INTO Employees (Name, Age) VALUES (@Name, @Age)", new { Name = "John", Age = 30 }, transaction);
        connection.Execute("INSERT INTO Employees (Name, Age) VALUES (@Name, @Age)", new { Name = "Jane", Age = 35 }, transaction);
        transaction.Commit();
    }
    catch
    {
        transaction.Rollback();
        throw;
    }
} Use Dapper.Contrib Dapper.Contrib is an open-source library that provides a set of extension methods to Dapper, which can help you to perform CRUD (Create, Read, Update, Delete) operations more efficiently. With Dapper.Contrib, you can use simple methods like Insert, Update, Delete, and Get to perform these operations instead of writing complex SQL queries. Here is an example of using Dapper.Contrib to performing CRUD operations: connection.Insert(new Employee { Name = "John", Age = 30 });
connection.Update(new Employee { EmployeeId = 1, Name = "Jane", Age = 35 });
connection.Delete(new Employee { EmployeeId = 1 });
var employee = connection.Get<Employee>(1); Use Mapping: Dapper allows you to map query results to C# objects. Mapping can help you work with data more naturally, saving you a lot of time when working with large data sets. Dapper supports automatic and manual mapping, and you can choose the best method for your application. Here is an example of using manual mapping with Dapper: public class Employee
{
    public int EmployeeId { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

var employees = connection.Query("SELECT * FROM Employees").Select(x => new Employee
{
    EmployeeId = (int)x.EmployeeId,
    Name = (string)x.Name,
    Age = (int)x.Age
}); Use Connection Pooling Dapper works well with connection pooling, which can help you improve your application's performance. Connection pooling allows you to reuse existing database connections instead of creating new connections each time you need to access the database. This can reduce the overhead associated with making new connections, and it can help to improve the overall performance of your application. Here is an example of using connection pooling with Dapper: var connectionString = "Data Source=myServerAddress;Initial Catalog=myDataBase;User Id=myUsername;Password=myPassword;Pooling=true;";
var connection = new SqlConnection(connectionString); Use Query Helpers Dapper provides several query helpers that can help you to write more complex queries more efficiently. Query helpers allow you to write difficult questions using simple methods, which can reduce the amount of code you need to write. Query helpers can perform joins, aggregate functions, and other advanced operations. Here is an example of using query helpers with Dapper: connection.Query<Employee, Department, Employee>("SELECT e.*, d.* FROM Employees e JOIN Departments d ON e.DepartmentId = d.DepartmentId WHERE e.EmployeeId = @EmployeeId", (employee, department) =>
{
    employee.Department = department;
    return employee;
}, new { EmployeeId = 1 }, splitOn: "DepartmentId"); Use the 'Using' Statement The 'using' statement is a C# construct that allows you to dispose of resources when they are no longer needed automatically. When working with databases, it is essential to ensure that database connections are properly closed when no longer required. The 'using' statement can help you to do this automatically, ensuring that database connections are closed, and resources are correctly disposed of. Here is an example of using the 'using' statement with Dapper: using (var connection = new SqlConnection(connectionString))
{
    connection.Open();
    // Query or Execute statements
} Use Performance Profiling Finally, it's essential to use performance profiling tools to identify performance bottlenecks in your application. Dapper is designed to be fast and efficient, but there may be situations where you need to optimize your queries or database schema to improve performance. Performance profiling tools can help you to identify these bottlenecks and make the necessary changes to improve performance. Conclusion These best practices can help you to use Dapper more effectively in your C# applications. Following these best practices allows you to write cleaner, more maintainable, and more performant code when working with databases. Use connection pooling to improve performance, use query helpers to write complex queries more efficiently, use the 'using' statement to automatically dispose of resources, and use performance profiling tools to identify performance bottlenecks. By following these best practices, you can make the most of Dapper in your C# applications. Follow me on , , , , C# Publication LinkedIn Instagram Twitter Dev.to Also Published Here

Stories, News & Mentions about ADDEPAR

Addepar’s Stories on HackerNoon

Addepar's News & Mentions