All projects start with a lot of enthusiasm. As many projects grow the technical debt gets bigger and the enthusiasm gets less. Almost any developer can develop a great project, but the key is maintaining an ever evolving application with minimal technical debt without loosing enthusiasm.
During this talk you will be taken on the journey of application design. The starting point is an application that looks fine but contains lots of potential pitfalls. We will address the problems and solve them with beautiful design. We end up with testable, nicely separated software with a clear intention.
Hacking Your Way To Better Security - Dutch PHP Conference 2016Colin O'Dell
The goal of this talk is to educate developers on common security vulnerabilities, how they are exploited, and how to protect against them. We'll explore several of the OWASP Top 10 attack vectors like SQL injection, XSS, CSRF, session hijacking, and insecure direct object references. Each topic will be approached from the perspective of an attacker to see how these vulnerabilities are detected and exploited using several realistic examples. Once we've established an understanding of how these attacks work, we'll look at concrete steps you can take to secure web applications against such vulnerabilities. The knowledge gained from this talk can also be used for participating in "Capture the Flag" security competitions.
Un gioco in cui vincono tutti o due piccioni con una fava ;)
Lavorare rivolti alla creazione di valore per il cliente e da questo ottenere una libreria quasi pronta per essere pubblicata
Mirror, mirror on the wall: Building a new PHP reflection library (DPC 2016)James Titcumb
Have you ever used PHP's built in reflection, only to find you can't do quite what you wanted? What about finding types for parameters or properties? What about reflecting on classes that aren't loaded, so that you can modify them directly?
Better Reflection is an awesome new library that uses magical time-warp techniques* (*actual magic or time-warp not guaranteed) to improve on PHP's built-in reflection by providing additional functionality. In this talk we'll cover what reflection is all about, explore the cool features of Better Reflection already implemented, the difficulties we faced actually writing the thing, and how you can use Better Reflection in your projects to maximise your reflection-fu.
What should you test with your unit tests? Some people will say that unit behaviour is best tested through it's outcomes. But what if communication between units itself is more important than the results of it? This session will introduce you to two different ways of unit-testing and show you a way to assert your object behaviours through their communications.
How do you create applications with an incredible level of extendability without losing readability in the process? What if there's a way to separate concerns not only on the code, but on the service definition level? This talk will explore structural and behavioural patterns and ways to enrich them through tricks of powerful dependency injection containers such as Symfony2 DIC component.
Hacking Your Way To Better Security - Dutch PHP Conference 2016Colin O'Dell
The goal of this talk is to educate developers on common security vulnerabilities, how they are exploited, and how to protect against them. We'll explore several of the OWASP Top 10 attack vectors like SQL injection, XSS, CSRF, session hijacking, and insecure direct object references. Each topic will be approached from the perspective of an attacker to see how these vulnerabilities are detected and exploited using several realistic examples. Once we've established an understanding of how these attacks work, we'll look at concrete steps you can take to secure web applications against such vulnerabilities. The knowledge gained from this talk can also be used for participating in "Capture the Flag" security competitions.
Un gioco in cui vincono tutti o due piccioni con una fava ;)
Lavorare rivolti alla creazione di valore per il cliente e da questo ottenere una libreria quasi pronta per essere pubblicata
Mirror, mirror on the wall: Building a new PHP reflection library (DPC 2016)James Titcumb
Have you ever used PHP's built in reflection, only to find you can't do quite what you wanted? What about finding types for parameters or properties? What about reflecting on classes that aren't loaded, so that you can modify them directly?
Better Reflection is an awesome new library that uses magical time-warp techniques* (*actual magic or time-warp not guaranteed) to improve on PHP's built-in reflection by providing additional functionality. In this talk we'll cover what reflection is all about, explore the cool features of Better Reflection already implemented, the difficulties we faced actually writing the thing, and how you can use Better Reflection in your projects to maximise your reflection-fu.
What should you test with your unit tests? Some people will say that unit behaviour is best tested through it's outcomes. But what if communication between units itself is more important than the results of it? This session will introduce you to two different ways of unit-testing and show you a way to assert your object behaviours through their communications.
How do you create applications with an incredible level of extendability without losing readability in the process? What if there's a way to separate concerns not only on the code, but on the service definition level? This talk will explore structural and behavioural patterns and ways to enrich them through tricks of powerful dependency injection containers such as Symfony2 DIC component.
Software development is riddled with explicit and implicit costs. Every decision you make has a cost attached to it. When you're writing code, you're making an investment, the size of which will for a long time define the costs of your future growth. Making right decision about these investments is very tricky and the cost of wrong decisions might be crippling for both business and teams that support it.
Extreme Programming and Test Driven Development in particular are practices that are aiming at supporting development effort by making it easier to introduce change. That said, sometimes those tools can become a problem of its own when applied in the wrong way or for the wrong context. Understanding software cost forces is a very important skill of successful teams and something that helps understand how to apply XP and TDD in different contexts.
Software development is riddled with explicit and implicit costs. Every decision you make has a cost attached to it. When you're writing code, you're making an investment, the size of which will for a long time define the costs of your future growth. In this talk you will learn how to see, understand and game some of these forces in your favour.
“Writing code that lasts” … or writing code you won’t hate tomorrow. - PHPKonfRafael Dohms
As developers we write code everyday, only to frown at it a week after that. Why do we have such a hard time with code written by others and ourselves, this raging desire to rewrite everything we see? Writing code that survives the test of time and self judgment is a matter of clarity and simplicity. Let's talk about growing, learning and improving our code with calisthenics, readability and good design.
Design Patterns avec PHP 5.3, Symfony et PimpleHugo Hamon
Cette conférence présente deux grands motifs de conception : l'observateur et l'injection de dépendance. Ce sujet allie à la fois théorie et pratique. Le composant autonome EventDispatcher de Symfony ainsi que le conteneur d'injection de dépendance Pimple sont mis à l'honneur avec des exemples pratiques d'usage. Ces cas pratiques combinent du code de l'ORM Propel ainsi que le composant autonome Zend\Search\Lucene du Zend Framework 2
A lot of people using PHPunit for testing their source code. While I was observing my team I recognized most of them are only using the standard assertions like 'assertEquals()' and are complaining about how hard it is to test the code even when the tests are written first. This talk is about all the stuff not used on a daily basis and it digs deep into uncommon features of PHPUnit.
The IoC Hydra - Dutch PHP Conference 2016Kacper Gunia
Slides from my talk presented during Dutch PHP Conference in Amsterdam - 25 June 2016
More Domain-Driven Design related content at: https://domaincentric.net/
We, as developers, often think that we don’t have to or don’t need to know what are what they call design patterns. We think that we already know how to build a software and don’t need all this theory. Years after years, by having to deal with the low maintainability of my own codebases, I explored a lot of ways of decoupling applications, in order to have enterprise-grade software that last for years. With concrete examples, I want to share with you some design patterns and how they can help you to grow well structured and decoupled applications.
You must’ve heard of Unit testing… If not, then this talk is definitely for you! If you do know Unit testing, you probably ran at some point into a hurdle: “Where do I start?” And despite your best efforts, you end up not having enough tests for your application – Then that change request comes in, requiring you to change that very same complex piece of code for which you are lacking tests! How do you going refactor while maintaining all those ‘undocumented’ business rules? This talk will show how Codeception can be leveraged to refactor the visuals aspects of an application, maintaining backwards compatibility on API changes and even assist in moving to a whole different server infrastructure.
Slides from my talk at the GTA-PHP Meetup Group about getting mixed HTML / PHP code into objects using SOLID principles.
Meetup page: http://www.meetup.com/GTA-PHP-User-Group-Toronto/events/230656470/
Code is on github: https://github.com/zymsys/solid
Symfony World - Symfony components and design patternsŁukasz Chruściel
There are so many Symfony components already, and they have some pretty neat perks. But have you seen them in action?
Design patterns are not a silver bullet. They will never resolve your problem on their own. On the other hand, design patterns provide a common ground for developers without going into details and could be used as building bricks to solve some more advanced problems.
During my presentation, I will take a closer look and explain the appliance of selected design patterns. What is more, I will take advantage of the Symfony ecosystem to implement them with ease.
I will do the presentation on sample code that developers will understand at all levels of expertise.
Silex is a brand new PHP 5.3 micro framework built on top of the Symfony2 de decoupled components. In this session, we will discover how to build and deploy powerful REST web services with such a micro framework and its embedded tools.
The first part of this talk will introduce the basics of the REST architecture. We fill focus on the main concepts of REST like HTTP methods, URIs and open formats like XML and JSON.
Then, we will discover how to deploy REST services using most of interesting Silex tools like database abstraction layer, template engine and input validation. We will also look at unit and functional testing frameworks with PHPUnit and HTTP caching with Edge Side Includes and Varnish support to improve performances.
November Camp - Spec BDD with PHPSpec 2Kacper Gunia
My slides on PHPSpec 2 from Symfony November Camp Stockholm.
www.symfony.se/november-camp/
More Domain-Driven Design related content at: https://domaincentric.net/
Adding Dependency Injection to Legacy ApplicationsSam Hennessy
Dependency Injection (DI) is a fantastic technique, but what if you what to use dependency injection in your legacy application. Fear not! As someone who as done this very thing, I will show how you can successful and incrementally add DI to any application. I will present a number of recipes and solutions to common problems and give a tour of the various PHP DI projects and how they can help.
Come to this talk prepared to learn about the Doctrine PHP open source project. The Doctrine project has been around for over a decade and has evolved from database abstraction software that dates back to the PEAR days. The packages provided by the Doctrine project have been downloaded almost 500 million times from packagist. In this talk we will take you through how to get started with Doctrine and how to take advantage of some of the more advanced features.
SOLID - a set of concepts for designing maintainable and understandable software - yet some of these ideas can be hard to understand themselves. Scholarly definitions and generic examples of these are often still confusing and not applicable to real world applications. By taking a look at an actual application, we'll explore these principles in action, and demonstrate the benefits of following them.
Software development is riddled with explicit and implicit costs. Every decision you make has a cost attached to it. When you're writing code, you're making an investment, the size of which will for a long time define the costs of your future growth. Making right decision about these investments is very tricky and the cost of wrong decisions might be crippling for both business and teams that support it.
Extreme Programming and Test Driven Development in particular are practices that are aiming at supporting development effort by making it easier to introduce change. That said, sometimes those tools can become a problem of its own when applied in the wrong way or for the wrong context. Understanding software cost forces is a very important skill of successful teams and something that helps understand how to apply XP and TDD in different contexts.
Software development is riddled with explicit and implicit costs. Every decision you make has a cost attached to it. When you're writing code, you're making an investment, the size of which will for a long time define the costs of your future growth. In this talk you will learn how to see, understand and game some of these forces in your favour.
“Writing code that lasts” … or writing code you won’t hate tomorrow. - PHPKonfRafael Dohms
As developers we write code everyday, only to frown at it a week after that. Why do we have such a hard time with code written by others and ourselves, this raging desire to rewrite everything we see? Writing code that survives the test of time and self judgment is a matter of clarity and simplicity. Let's talk about growing, learning and improving our code with calisthenics, readability and good design.
Design Patterns avec PHP 5.3, Symfony et PimpleHugo Hamon
Cette conférence présente deux grands motifs de conception : l'observateur et l'injection de dépendance. Ce sujet allie à la fois théorie et pratique. Le composant autonome EventDispatcher de Symfony ainsi que le conteneur d'injection de dépendance Pimple sont mis à l'honneur avec des exemples pratiques d'usage. Ces cas pratiques combinent du code de l'ORM Propel ainsi que le composant autonome Zend\Search\Lucene du Zend Framework 2
A lot of people using PHPunit for testing their source code. While I was observing my team I recognized most of them are only using the standard assertions like 'assertEquals()' and are complaining about how hard it is to test the code even when the tests are written first. This talk is about all the stuff not used on a daily basis and it digs deep into uncommon features of PHPUnit.
The IoC Hydra - Dutch PHP Conference 2016Kacper Gunia
Slides from my talk presented during Dutch PHP Conference in Amsterdam - 25 June 2016
More Domain-Driven Design related content at: https://domaincentric.net/
We, as developers, often think that we don’t have to or don’t need to know what are what they call design patterns. We think that we already know how to build a software and don’t need all this theory. Years after years, by having to deal with the low maintainability of my own codebases, I explored a lot of ways of decoupling applications, in order to have enterprise-grade software that last for years. With concrete examples, I want to share with you some design patterns and how they can help you to grow well structured and decoupled applications.
You must’ve heard of Unit testing… If not, then this talk is definitely for you! If you do know Unit testing, you probably ran at some point into a hurdle: “Where do I start?” And despite your best efforts, you end up not having enough tests for your application – Then that change request comes in, requiring you to change that very same complex piece of code for which you are lacking tests! How do you going refactor while maintaining all those ‘undocumented’ business rules? This talk will show how Codeception can be leveraged to refactor the visuals aspects of an application, maintaining backwards compatibility on API changes and even assist in moving to a whole different server infrastructure.
Slides from my talk at the GTA-PHP Meetup Group about getting mixed HTML / PHP code into objects using SOLID principles.
Meetup page: http://www.meetup.com/GTA-PHP-User-Group-Toronto/events/230656470/
Code is on github: https://github.com/zymsys/solid
Symfony World - Symfony components and design patternsŁukasz Chruściel
There are so many Symfony components already, and they have some pretty neat perks. But have you seen them in action?
Design patterns are not a silver bullet. They will never resolve your problem on their own. On the other hand, design patterns provide a common ground for developers without going into details and could be used as building bricks to solve some more advanced problems.
During my presentation, I will take a closer look and explain the appliance of selected design patterns. What is more, I will take advantage of the Symfony ecosystem to implement them with ease.
I will do the presentation on sample code that developers will understand at all levels of expertise.
Silex is a brand new PHP 5.3 micro framework built on top of the Symfony2 de decoupled components. In this session, we will discover how to build and deploy powerful REST web services with such a micro framework and its embedded tools.
The first part of this talk will introduce the basics of the REST architecture. We fill focus on the main concepts of REST like HTTP methods, URIs and open formats like XML and JSON.
Then, we will discover how to deploy REST services using most of interesting Silex tools like database abstraction layer, template engine and input validation. We will also look at unit and functional testing frameworks with PHPUnit and HTTP caching with Edge Side Includes and Varnish support to improve performances.
November Camp - Spec BDD with PHPSpec 2Kacper Gunia
My slides on PHPSpec 2 from Symfony November Camp Stockholm.
www.symfony.se/november-camp/
More Domain-Driven Design related content at: https://domaincentric.net/
Adding Dependency Injection to Legacy ApplicationsSam Hennessy
Dependency Injection (DI) is a fantastic technique, but what if you what to use dependency injection in your legacy application. Fear not! As someone who as done this very thing, I will show how you can successful and incrementally add DI to any application. I will present a number of recipes and solutions to common problems and give a tour of the various PHP DI projects and how they can help.
Come to this talk prepared to learn about the Doctrine PHP open source project. The Doctrine project has been around for over a decade and has evolved from database abstraction software that dates back to the PEAR days. The packages provided by the Doctrine project have been downloaded almost 500 million times from packagist. In this talk we will take you through how to get started with Doctrine and how to take advantage of some of the more advanced features.
SOLID - a set of concepts for designing maintainable and understandable software - yet some of these ideas can be hard to understand themselves. Scholarly definitions and generic examples of these are often still confusing and not applicable to real world applications. By taking a look at an actual application, we'll explore these principles in action, and demonstrate the benefits of following them.
SOLID – a set of concepts for designing maintainable and understandable software – yet some of these ideas can be hard to understand themselves. Scholarly definitions and generic examples of these are often still confusing and not applicable to real world applications. By taking a look at an actual application, we’ll explore these principles in action, and demonstrate the benefits of following them.
Writing readable code is one of the most important aspects of web development. A developer should write code which another human is able to understand without the help of too many comments.
This talk will show you how to tidy up your code and write readable PHP.
https://speakerdeck.com/willroth/50-laravel-tricks-in-50-minutes - origin
Laravel 5.1 raised the bar for framework documentation, but there's much, much more lurking beneath the surface. In this 50-minute session, we'll explore 50 (yes, 50!) high-leverage implementation tips & tricks that you just won't find in the docs: the IoC Container, Blade, Eloquent, Middleware, Routing, Commands, Queues, Events, Caching — we'll cover them all! Join us as we drink from the fire hose & learn to take advantage of everything that Laravel has to offer to build better software faster!
The REST API is an awesome plugin to expose your data from the WordPress core. But … the standard implementation might not fit your specific case.
Just like the WordPress core, you'll be able to extend it to your specific needs. I'll show you how to handle authentication, introduce caching strategies, alter custom post types, or even change the default way of communication altogether.
You've seen Kris' open source libraries, but how does he tackle coding out an application? Walk through green fields with a Symfony expert as he takes his latest “next big thing” idea from the first line of code to a functional prototype. Learn design patterns and principles to guide your way in organizing your own code and take home some practical examples to kickstart your next project.
By the sum of PHPUnit assertion power and Symfony2 functional testing tools the developer can obtain a deep control on the developed application.
Here you can find some suggestions on how to leverage that power.
Project link and video: https://github.com/nafizmd09/Student-Result-Management-System-with-PHP--Nafiz
Student Result Management System project with MySQL server.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Name: Nafiz Md Imtiaz Uddin
B.Sc. student of Computer Science & Technology (江西理工大学) [2019-2023]
personal Email: nafizmdimtiazuddin@yahoo.com
Academic Email: 2520190011@mail.jxust.edu.cn
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The REST API is an awesome plugin to expose your data from the WordPress core. But … the standard implementation might not fit your specific case.
Just like the WordPress core, you'll be able to extend it to your specific needs. I'll show you how to handle authentication, introduce caching strategies, alter custom post types, or even change the default way of communication altogether.
You’ve seen Kris’ open source libraries, but how does he tackle coding out an application? Walk through green fields with a Symfony expert as he takes his latest “next big thing” idea from the first line of code to a functional prototype. Learn design patterns and principles to guide your way in organizing your own code and take home some practical examples to kickstart your next project.
Quarkus Hidden and Forbidden ExtensionsMax Andersen
Quarkus has a vast extension ecosystem and is known for its subsonic and subatomic feature set. Some of these features are not as well known, and some extensions are less talked about, but that does not make them less interesting - quite the opposite.
Come join this talk to see some tips and tricks for using Quarkus and some of the lesser known features, extensions and development techniques.
Field Employee Tracking System| MiTrack App| Best Employee Tracking Solution|...informapgpstrackings
Keep tabs on your field staff effortlessly with Informap Technology Centre LLC. Real-time tracking, task assignment, and smart features for efficient management. Request a live demo today!
For more details, visit us : https://informapuae.com/field-staff-tracking/
Globus Compute wth IRI Workflows - GlobusWorld 2024Globus
As part of the DOE Integrated Research Infrastructure (IRI) program, NERSC at Lawrence Berkeley National Lab and ALCF at Argonne National Lab are working closely with General Atomics on accelerating the computing requirements of the DIII-D experiment. As part of the work the team is investigating ways to speedup the time to solution for many different parts of the DIII-D workflow including how they run jobs on HPC systems. One of these routes is looking at Globus Compute as a way to replace the current method for managing tasks and we describe a brief proof of concept showing how Globus Compute could help to schedule jobs and be a tool to connect compute at different facilities.
Experience our free, in-depth three-part Tendenci Platform Corporate Membership Management workshop series! In Session 1 on May 14th, 2024, we began with an Introduction and Setup, mastering the configuration of your Corporate Membership Module settings to establish membership types, applications, and more. Then, on May 16th, 2024, in Session 2, we focused on binding individual members to a Corporate Membership and Corporate Reps, teaching you how to add individual members and assign Corporate Representatives to manage dues, renewals, and associated members. Finally, on May 28th, 2024, in Session 3, we covered questions and concerns, addressing any queries or issues you may have.
For more Tendenci AMS events, check out www.tendenci.com/events
How Recreation Management Software Can Streamline Your Operations.pptxwottaspaceseo
Recreation management software streamlines operations by automating key tasks such as scheduling, registration, and payment processing, reducing manual workload and errors. It provides centralized management of facilities, classes, and events, ensuring efficient resource allocation and facility usage. The software offers user-friendly online portals for easy access to bookings and program information, enhancing customer experience. Real-time reporting and data analytics deliver insights into attendance and preferences, aiding in strategic decision-making. Additionally, effective communication tools keep participants and staff informed with timely updates. Overall, recreation management software enhances efficiency, improves service delivery, and boosts customer satisfaction.
Check out the webinar slides to learn more about how XfilesPro transforms Salesforce document management by leveraging its world-class applications. For more details, please connect with sales@xfilespro.com
If you want to watch the on-demand webinar, please click here: https://www.xfilespro.com/webinars/salesforce-document-management-2-0-smarter-faster-better/
Software Engineering, Software Consulting, Tech Lead.
Spring Boot, Spring Cloud, Spring Core, Spring JDBC, Spring Security,
Spring Transaction, Spring MVC,
Log4j, REST/SOAP WEB-SERVICES.
Providing Globus Services to Users of JASMIN for Environmental Data AnalysisGlobus
JASMIN is the UK’s high-performance data analysis platform for environmental science, operated by STFC on behalf of the UK Natural Environment Research Council (NERC). In addition to its role in hosting the CEDA Archive (NERC’s long-term repository for climate, atmospheric science & Earth observation data in the UK), JASMIN provides a collaborative platform to a community of around 2,000 scientists in the UK and beyond, providing nearly 400 environmental science projects with working space, compute resources and tools to facilitate their work. High-performance data transfer into and out of JASMIN has always been a key feature, with many scientists bringing model outputs from supercomputers elsewhere in the UK, to analyse against observational or other model data in the CEDA Archive. A growing number of JASMIN users are now realising the benefits of using the Globus service to provide reliable and efficient data movement and other tasks in this and other contexts. Further use cases involve long-distance (intercontinental) transfers to and from JASMIN, and collecting results from a mobile atmospheric radar system, pushing data to JASMIN via a lightweight Globus deployment. We provide details of how Globus fits into our current infrastructure, our experience of the recent migration to GCSv5.4, and of our interest in developing use of the wider ecosystem of Globus services for the benefit of our user community.
Exploring Innovations in Data Repository Solutions - Insights from the U.S. G...Globus
The U.S. Geological Survey (USGS) has made substantial investments in meeting evolving scientific, technical, and policy driven demands on storing, managing, and delivering data. As these demands continue to grow in complexity and scale, the USGS must continue to explore innovative solutions to improve its management, curation, sharing, delivering, and preservation approaches for large-scale research data. Supporting these needs, the USGS has partnered with the University of Chicago-Globus to research and develop advanced repository components and workflows leveraging its current investment in Globus. The primary outcome of this partnership includes the development of a prototype enterprise repository, driven by USGS Data Release requirements, through exploration and implementation of the entire suite of the Globus platform offerings, including Globus Flow, Globus Auth, Globus Transfer, and Globus Search. This presentation will provide insights into this research partnership, introduce the unique requirements and challenges being addressed and provide relevant project progress.
First Steps with Globus Compute Multi-User EndpointsGlobus
In this presentation we will share our experiences around getting started with the Globus Compute multi-user endpoint. Working with the Pharmacology group at the University of Auckland, we have previously written an application using Globus Compute that can offload computationally expensive steps in the researcher's workflows, which they wish to manage from their familiar Windows environments, onto the NeSI (New Zealand eScience Infrastructure) cluster. Some of the challenges we have encountered were that each researcher had to set up and manage their own single-user globus compute endpoint and that the workloads had varying resource requirements (CPUs, memory and wall time) between different runs. We hope that the multi-user endpoint will help to address these challenges and share an update on our progress here.
AI Pilot Review: The World’s First Virtual Assistant Marketing SuiteGoogle
AI Pilot Review: The World’s First Virtual Assistant Marketing Suite
👉👉 Click Here To Get More Info 👇👇
https://sumonreview.com/ai-pilot-review/
AI Pilot Review: Key Features
✅Deploy AI expert bots in Any Niche With Just A Click
✅With one keyword, generate complete funnels, websites, landing pages, and more.
✅More than 85 AI features are included in the AI pilot.
✅No setup or configuration; use your voice (like Siri) to do whatever you want.
✅You Can Use AI Pilot To Create your version of AI Pilot And Charge People For It…
✅ZERO Manual Work With AI Pilot. Never write, Design, Or Code Again.
✅ZERO Limits On Features Or Usages
✅Use Our AI-powered Traffic To Get Hundreds Of Customers
✅No Complicated Setup: Get Up And Running In 2 Minutes
✅99.99% Up-Time Guaranteed
✅30 Days Money-Back Guarantee
✅ZERO Upfront Cost
See My Other Reviews Article:
(1) TubeTrivia AI Review: https://sumonreview.com/tubetrivia-ai-review
(2) SocioWave Review: https://sumonreview.com/sociowave-review
(3) AI Partner & Profit Review: https://sumonreview.com/ai-partner-profit-review
(4) AI Ebook Suite Review: https://sumonreview.com/ai-ebook-suite-review
Listen to the keynote address and hear about the latest developments from Rachana Ananthakrishnan and Ian Foster who review the updates to the Globus Platform and Service, and the relevance of Globus to the scientific community as an automation platform to accelerate scientific discovery.
Code reviews are vital for ensuring good code quality. They serve as one of our last lines of defense against bugs and subpar code reaching production.
Yet, they often turn into annoying tasks riddled with frustration, hostility, unclear feedback and lack of standards. How can we improve this crucial process?
In this session we will cover:
- The Art of Effective Code Reviews
- Streamlining the Review Process
- Elevating Reviews with Automated Tools
By the end of this presentation, you'll have the knowledge on how to organize and improve your code review proces
Globus Connect Server Deep Dive - GlobusWorld 2024Globus
We explore the Globus Connect Server (GCS) architecture and experiment with advanced configuration options and use cases. This content is targeted at system administrators who are familiar with GCS and currently operate—or are planning to operate—broader deployments at their institution.
How to Position Your Globus Data Portal for Success Ten Good PracticesGlobus
Science gateways allow science and engineering communities to access shared data, software, computing services, and instruments. Science gateways have gained a lot of traction in the last twenty years, as evidenced by projects such as the Science Gateways Community Institute (SGCI) and the Center of Excellence on Science Gateways (SGX3) in the US, The Australian Research Data Commons (ARDC) and its platforms in Australia, and the projects around Virtual Research Environments in Europe. A few mature frameworks have evolved with their different strengths and foci and have been taken up by a larger community such as the Globus Data Portal, Hubzero, Tapis, and Galaxy. However, even when gateways are built on successful frameworks, they continue to face the challenges of ongoing maintenance costs and how to meet the ever-expanding needs of the community they serve with enhanced features. It is not uncommon that gateways with compelling use cases are nonetheless unable to get past the prototype phase and become a full production service, or if they do, they don't survive more than a couple of years. While there is no guaranteed pathway to success, it seems likely that for any gateway there is a need for a strong community and/or solid funding streams to create and sustain its success. With over twenty years of examples to draw from, this presentation goes into detail for ten factors common to successful and enduring gateways that effectively serve as best practices for any new or developing gateway.
Innovating Inference - Remote Triggering of Large Language Models on HPC Clus...Globus
Large Language Models (LLMs) are currently the center of attention in the tech world, particularly for their potential to advance research. In this presentation, we'll explore a straightforward and effective method for quickly initiating inference runs on supercomputers using the vLLM tool with Globus Compute, specifically on the Polaris system at ALCF. We'll begin by briefly discussing the popularity and applications of LLMs in various fields. Following this, we will introduce the vLLM tool, and explain how it integrates with Globus Compute to efficiently manage LLM operations on Polaris. Attendees will learn the practical aspects of setting up and remotely triggering LLMs from local machines, focusing on ease of use and efficiency. This talk is ideal for researchers and practitioners looking to leverage the power of LLMs in their work, offering a clear guide to harnessing supercomputing resources for quick and effective LLM inference.
Climate Science Flows: Enabling Petabyte-Scale Climate Analysis with the Eart...Globus
The Earth System Grid Federation (ESGF) is a global network of data servers that archives and distributes the planet’s largest collection of Earth system model output for thousands of climate and environmental scientists worldwide. Many of these petabyte-scale data archives are located in proximity to large high-performance computing (HPC) or cloud computing resources, but the primary workflow for data users consists of transferring data, and applying computations on a different system. As a part of the ESGF 2.0 US project (funded by the United States Department of Energy Office of Science), we developed pre-defined data workflows, which can be run on-demand, capable of applying many data reduction and data analysis to the large ESGF data archives, transferring only the resultant analysis (ex. visualizations, smaller data files). In this talk, we will showcase a few of these workflows, highlighting how Globus Flows can be used for petabyte-scale climate analysis.
A Comprehensive Look at Generative AI in Retail App Testing.pdfkalichargn70th171
Traditional software testing methods are being challenged in retail, where customer expectations and technological advancements continually shape the landscape. Enter generative AI—a transformative subset of artificial intelligence technologies poised to revolutionize software testing.
Enhancing Research Orchestration Capabilities at ORNL.pdfGlobus
Cross-facility research orchestration comes with ever-changing constraints regarding the availability and suitability of various compute and data resources. In short, a flexible data and processing fabric is needed to enable the dynamic redirection of data and compute tasks throughout the lifecycle of an experiment. In this talk, we illustrate how we easily leveraged Globus services to instrument the ACE research testbed at the Oak Ridge Leadership Computing Facility with flexible data and task orchestration capabilities.
18. public function __construct(string $name, string $email)
{
$this->setName($name);
$this->setEmail($email);
}
private function setName(string $name)
{
if ('' === $name) {
throw new InvalidArgumentException('Name is required');
}
$this->name = $name;
}
private function setEmail(string $email)
{
if ('' === $email) {
throw new InvalidArgumentException('E-mail is required');
}
$this->email = $email;
}
Model
20. private function setEmail(string $email)
{
if ('' === $email) {
throw new InvalidArgumentException('E-mail is required');
}
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException('E-mail is invalid');
}
$this->email = $email;
}
Model
25. final class EmailAddress
{
public function __construct(string $email)
{
if ('' === $email) {
throw new InvalidArgumentException('E-mail is required');
}
}
}
Value object
26. final class EmailAddress
{
public function __construct(string $email)
{
if ('' === $email) {
throw new InvalidArgumentException('E-mail is required');
}
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException('E-mail is invalid');
}
}
}
Value object
27. final class EmailAddress
{
public function __construct(string $email)
{
if ('' === $email) {
throw new InvalidArgumentException('E-mail is required');
}
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException('E-mail is invalid');
}
$this->email = $email;
}
}
Value object
28. final class EmailAddress
{
public function __construct(string $email)
{
if ('' === $email) {
throw new InvalidArgumentException('E-mail is required');
}
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException('E-mail is invalid');
}
$this->email = $email;
}
public function toString() : string;
}
Value object
29. final class EmailAddress
{
public function __construct(string $email)
{
if ('' === $email) {
throw new InvalidArgumentException('E-mail is required');
}
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException('E-mail is invalid');
}
$this->email = $email;
}
public function toString() : string;
public function equals(EmailAddress $email) : bool;
}
Value object
30. class User
{
public function __construct(EmailAddress $email, string $name)
{
$this->setEmail($email);
$this->setName($name);
}
//[..]
}
Model
47. Some observation
We are now directly using doctrine for persistence
A change of persistence would mean changing
every class where we save or retrieve the user
48. public function registerAction(Request $request) : Response
{
// [..]
$user = new User(new EmailAddress($data['email']), $data['name']);
$this->em->persist($user);
$this->em>flush();
}
Controller
70. class RegisterUser // A command always has a clear intention
{
public function __construct(string $email, string $name)
{
$this->email = $email;
$this->name = $name;
}
// Getters
}
Command
73. class RegisterUserHandler
{
//[..]
public function handle(RegisterUser $registerUser)
{
$user = new User(new EmailAddress($registerUser->getEmail()), $registerUser->getName());
$this->userRepository->save($user);
}
}
Command handler
74. class RegisterUserHandler
{
//[..]
public function handle(RegisterUser $registerUser)
{
$user = new User(new EmailAddress($registerUser->getEmail()), $registerUser->getName());
$this->userRepository->save($user);
$this->userRegisteredNotifier->notify($registerUser->getEmail()), $registerUser->getName());
}
}
Command handler
75. public function registerAction(Request $request) : Response
{
if ($form->isValid()) {
// [..]
$data = $form->getData();
$this->registerUserHandler->handle(
new RegisterUser($data['email'], $data['name'])
);
}
}
Controller
76. public function registerAction(Request $request) : JsonResponse
{
// [..]
$this->registerUserHandler->handle(
new RegisterUser($data['email'], $data['name'])
);
return new JsonResponse([]);
}
Controller
85. A command bus is a generic command handler
Commands and the
command bus
86. Commands and the
command bus
A command bus is a generic command handler
It receives a command and routes it to the handler
87. Commands and the
command bus
A command bus is a generic command handler
It receives a command and routes it to the handler
It provides the ability to add middleware
88. A great command bus
implementation
github.com/SimpleBus/MessageBus
89.
90. public function handle($command, callable $next)
{
$this->logger->log($this->level, 'Start, [command => $command]);
$next($command);
$this->logger->log($this->level, 'Finished', [command' => $command]);
}
Logging middleware example
91. public function handle($command, callable $next)
{
if ($this->canBeDelayed($command)) {
$this->commandQueue->add($command);
} else {
$next($command);
}
}
Queueing middleware example
100. class UserIsRegistered // An event tells us what has happened
{
public function __construct(int $userId, string $emailAddress, string $name)
{}
// Getters
}
Event
102. class User implements ContainsRecordedMessages
{
use PrivateMessageRecorderCapabilities;
//[..]
}
Model
103. class User implements ContainsRecordedMessages
{
use PrivateMessageRecorderCapabilities;
public static function register(EmailAddress $email, string $name) : self
{
}
//[..]
}
Model
104. class User implements ContainsRecordedMessages
{
use PrivateMessageRecorderCapabilities;
public static function register(EmailAddress $email, string $name) : self
{
$user = new self($email, $name);
}
//[..]
}
Model
105. class User implements ContainsRecordedMessages
{
use PrivateMessageRecorderCapabilities;
public static function register(EmailAddress $email, string $name) : self
{
$user = new self($email, $name);
$user->record(new UserIsRegistered($user->id, (string) $email, $name));
}
//[..]
}
Model
106. class User implements ContainsRecordedMessages
{
use PrivateMessageRecorderCapabilities;
public static function register(EmailAddress $email, string $name) : self
{
$user = new self($email, $name);
$user->record(new UserIsRegistered($user->id, (string) $email, $name));
return $user;
}
//[..]
}
Model
107. class RegisterUserHandler
{
//[..]
public function handle(RegisterUser $registerUser)
{
// save user
foreach ($user->recordedMessages() as $event) {
$this->eventBus->handle($event);
}
}
}
Command handler
116. We now have a rich user model
It contains data
117. We now have a rich user model
It contains data
It contains validation
118. We now have a rich user model
It contains data
It contains validation
It contains behaviour
119. “Objects hide their data behind abstractions and expose
functions that operate on that data. Data structure expose
their data and have no meaningful functions.”
Robert C. Martin (uncle Bob)
121. We are still coupled to
doctrine for our persistence
122. class DoctrineUserRepository
{
//[..]
public function save(User $user)
{
$this->em->persist($user);
$this->em->flush();
}
public function find(int $userId) : User
{
return $this->em->find(User::class, $userId);
}
}
Repository
136. class DoctrineUserRepository implements UserRepositoryInterface
{
/**
* @throws DoctrineDBALExceptionConnectionException
*/
public function find(int $userId) : User;
}
class InMemoryUserRepository implements UserRepository
{
/**
* @throws RedisException
*/
public function find(int $userId) : User;
}
Repository
137. Don’t do this
class DoctrineUserRepository implements UserRepositoryInterface
{
/**
* @throws DoctrineDBALExceptionConnectionException
*/
public function find(int $userId) : User;
}
class InMemoryUserRepository implements UserRepository
{
/**
* @throws RedisException
*/
public function find(int $userId) : User;
}
Repository
138. class DoctrineUserRepository implements UserRepositoryInterface
{
public function find(UserId $userId) : User
{
try {
if ($user = $this->findById($userId)) {
return $user;
}
} catch (ConnectionException $e) {
throw ServiceUnavailableException::withOriginalException($e);
}
throw UserNotFoundException::withId($userId);
}
}
Normalize your exceptions
Repository
139. class DoctrineUserRepository implements UserRepositoryInterface
{
public function find(UserId $userId) : User
{
try {
if ($user = $this->findById($userId)) {
return $user;
}
} catch (ConnectionException $e) {
throw ServiceUnavailableException::withOriginalException($e);
}
throw UserNotFoundException::withId($userId);
}
}
Normalize your exceptions
The implementor now only has to worry about the exceptions
defined in the interface
Repository
140. The promise of a repository interface is now clear, simple and
implementation independent
143. src/UserBundle/
├── Command
├── Controller
├── Entity
├── Event
├── Form
├── Notifier
├── Repository
└── ValueObject
Let’s look at the structure
The domain, infrastructure and application are all
mixed in the bundle
159. There was 1 error:
1) UserDomainModelUserRegisterUserTest::can_register_user
UserDomainModelExceptionUserNotFoundException: User with id 1 not found
FAILURES!
Tests: 1, Assertions: 0, Errors: 1.
175. But a Uuid can still be any id
We can be more explicit
176. final class UserId // Simply wrapper of Uuid
{
public static function createNew() : self
/**
* @throws InvalidArgumentException
*/
public static function fromString(string $id) : self
public function toString() : string;
}
Value object
177. Now we know exactly what
we are talking about
178. public function can_register_user()
{
$id = UserId::createNew();
$this->registerUserHandler->handle(
new RegisterUser((string) $id, 'aart.staartjes@hotmail.com', 'Aart Staartjes')
);
$user = $this->inMemoryUserRepository->find($id);
// Assertions
}
179. phpunit --bootstrap vendor/autoload.php src/JO/User/
PHPUnit 4.8.11 by Sebastian Bergmann and contributors.
.
Time: 266 ms, Memory: 5.25Mb
OK (1 test, 4 assertions)
205. Intention revealing code
Testable code
Preventing the big ball of mud
Anemic domain models (anti pattern)
Value objects
What did we learn?
206. Intention revealing code
Testable code
Preventing the big ball of mud
Anemic domain models (anti pattern)
Value objects
Decoupling from the framework
What did we learn?
207. What did we learn?
Writing fast tests (mocked environment)
208. What did we learn?
Writing fast tests (mocked environment)
Commands
209. What did we learn?
Writing fast tests (mocked environment)
Commands
Domain Events
210. What did we learn?
Writing fast tests (mocked environment)
Commands
Domain Events
Dependency inversion principle
211. What did we learn?
Writing fast tests (mocked environment)
Commands
Domain Events
Dependency inversion principle
Up front id generation strategy
212. What did we learn?
Writing fast tests (mocked environment)
Commands
Domain Events
Dependency inversion principle
Up front id generation strategy
Creating powerful domain exceptions
213. What did we learn?
Writing fast tests (mocked environment)
Commands
Domain Events
Dependency inversion principle
Up front id generation strategy
Creating powerful domain exceptions
Liskov substitution principle
215. We wrote intention revealing code. Separated the
domain, infrastructure and application. Created
216. We wrote intention revealing code. Separated the
domain, infrastructure and application. Created
abstractions to improve testability and flexibility. We
217. We wrote intention revealing code. Separated the
domain, infrastructure and application. Created
abstractions to improve testability and flexibility. We
used commands to communicate with a unified
voice. Created domain events to allow for extension
218. We wrote intention revealing code. Separated the
domain, infrastructure and application. Created
abstractions to improve testability and flexibility. We
used commands to communicate with a unified
voice. Created domain events to allow for extension
without cluttering the existing code. We end up with
219. We wrote intention revealing code. Separated the
domain, infrastructure and application. Created
abstractions to improve testability and flexibility. We
used commands to communicate with a unified
voice. Created domain events to allow for extension
without cluttering the existing code. We end up with
clear, maintainable and beautiful software.
220. We wrote intention revealing code. Separated the
domain, infrastructure and application. Created
abstractions to improve testability and flexibility. We
used commands to communicate with a unified
voice. Created domain events to allow for extension
without cluttering the existing code. We end up with
clear, maintainable and beautiful software.
That keeps us excited!
We are going to walk through the process of building an application.
We will start with some poor decisions and improve bit by bit and explaining the choices I make
Show techniques to decrease technical dept, improve code readability and maintainability
So that we end up with beautiful software
This is how every projects starts. A lot of excitement.
A clean sheet
This time I’m going to do everything the right way
At the start the amount of progress is huge
New features are added rapidly
Then it slows down
And after a year you are barely moving forward
You slow down due to the increase of technical dept
Technical debt will increase over time but your goal is to have a linear increase
You want to prevent the exponential growth in technical debt
You fix one thing and break two
Let’s prevent an exponential growth in technical depth
Lack of intention - You don’t immediately see what a piece of code is about
Lack of intention - You don’t immediately see what a piece of code is about
Heavy coupling - to delivery mechanisms like http and persistence mechanisms like MySQL en MongoDB
Anemic domain models - Important models for the business that contain no behaviour and no validation
We start with a requirement
We create our user model with getters and setters
We make a controller we check if the form is submitted and valid.
We then persist the data.
That one requirement handled.
We require the name and email in the constructor.
We then validate that they are not empty.
The customer comes in with the next requirement
We expand our email validation so that it also checks for the email format.
It’s becoming messy already
To solve this we can use a value object
It’s becoming messy already
To solve this we can use a value object
We can create a value object like this
The constructor simply takes the argument as a string
We validate the the email is not empty
And that the email is in a valid format
And only then we assign the email to the user
Add a toString got retrieve the emailaddress
And we can add a check to check if two email addresses are the same.
The user can simply accept an email without worrying about validation
In the register user action we used to do $form->getData() to get a user
We now have to pass the required arguments to the user __construction
Our User is now always in a valid state
It looks like a small step but we made huge progress.
This means we can simplify other parts of the application
If we can not rely on the User to be in a valid state we place validation all over our application
Because we force our model to always be in a valid state
We can simplify this code
We can now just send our e-mail
Equality is based on value
The one 10 euro bill is the same as the other
It can still be different bills
If we were to create something for a bank, and care about each individual bill, then it would not be a value object.
The user always has a name and a valid e-mail
Everything clear?
Do you also know how to cope with form validation?
This is our current implementation, directly using the doctrine entity manager
We can simplify the controller and just call the save method
Render template
Create message
Send an email
The controller is rendering templates, creating messages and sending e-mails
We can easily extract the notifying
We separate this into it’s own class
We can now easily test it
We can now simply call the notifier.
The rendering, creating and sending of the mail message will be handled in the notifier.
Persistence is handled by the repository
And sending a confirmation message by the notifier
We create a new api controller
With a register action
That returns a JSON response
We get the request data
Create and save the user
Notify the user
and return a JsonResponse
We are duplicating the registration of a user
This will become problematic when adding more ways to register a user
or when adding new requirements to the registration
One simple command to register a new user
One simple handler
Creates the user
Saves the user
And notifies the user
One simple handler
Creates the user
Saves the user
And notifies the user
One simple handler
Creates the user
Saves the user
And notifies the user
One simple handler
Creates the user
Saves the user
And notifies the user
The web controller is now simply calling RegisterUserHandler::handle
We now always register a user in the same way
The command is always ignorant of the delivery mechanism.
If we want to add an auto generated password we only have to add it in the handler
There is always one to one relation
A command bus is a generic command handler
It receives a command and routes it to the handler
It provides the ability to add middleware
A command bus is a generic command handler
It receives a command and routes it to the handler
It provides the ability to add middleware
A command bus is a generic command handler
It receives a command and routes it to the handler
It provides the ability to add middleware
A command bus is a generic command handler
It receives a command and routes it to the handler
It provides the ability to add middleware
A command bus is a generic command handler
It receives a command and routes it to the handler
It provides the ability to add middleware
You can easily add logging to log every command in your application
We are still sending a confirmation message from within the handler
A simple object with the changed data
The ContainsRecordedMessages interface tells that we expose events.
The PrivateMessageRecorderCapabilities is a trait that allows us to record events and exposes them
The User::register method is an explicit way of creating a user. It also takes care of recording the event for us.
We can now let the eventbus publish all recorded messages
Handler publishes the event, the notifier and the logger listen
Some characteristics
We started with a data structure but we now have an object with meaningful behaviour
In our domain we have our UserRepository that uses doctrine to persist the user.
Our RegisterUserHandler shouldn’t deal with low level persistence
Our RegisterUserHandler shouldn’t deal with low level persistence
We can now rely on the interface instead of the concrete doctrine implementation
We are injecting the repository in the RegisterUserHandler
The RegisterUserHandler lets the repository handle the persistence
We don’t rely on low level details
We are injecting the repository in the RegisterUserHandler
The RegisterUserHandler lets the repository handle the persistence
We don’t rely on low level details
We are injecting the repository in the RegisterUserHandler
The RegisterUserHandler lets the repository handle the persistence
We don’t rely on low level details
Small step with huge benefits
Small step with huge benefits
Small step with huge benefits
The one relying on your interface only knows about the exceptions defined in that interface.It can not cope with every possible implementation
So this is the entire structure
The red classes are part of our domain. They contain the things that have the most value for our business.
They contain the business rules
The blue parts are infrastructural concerns.
The green parts are part of the application
The highlighted classes are part of our domain. The framework we happen to use is not important here
The highlighted classes are part of our infrastructure. The framework we happen to use is not important here
The highlighted classes are part of our application. The framework we happen to use is not important here
We are also less coupled to the framework.
A switch of framework or using a different framework for an api or microservice is now easier.
We are using a structure independent of the framework
I agree with this, because testable code is not always good code. But untestable code is almost always bad code.
We now require the persistence layer to handle id generation
And we don’t know the id until the user is registered
When using a command we will never know the id
There is still a problem
We are using generic exceptions that are used by almost any library
We can catch the very specific exception
We can catch the general domain exception
We can now catch the more explicit exceptions
We used the hexagonal architecture consisting of the inside and the outside
The application and the domain
The hexagonal architecture is also called ports and adapters
The number of ports on a hexagon is six. Six is an arbitrary number and not important here.
The domain doesn’t know anything about the delivery or persistence mechanisms
It contains our most import things, our business rules
Please give me some feedback.
Tell me what you liked and things I can improve
Clean code, DDD in PHP, Implement domain driven design
Carlos, the author of DDD in PHP is also present the Dutch PHP conference