Writing code is easy but writing maintainable code is almost impossible. During this talk I will discuss some of the principles of coding that relates to WordPress but goes beyond that.
Rule 1: Follow a consistent coding standard
Rule 2: Name things properly, long variable and function names are allowed
Rule 3: Be expressive, write code as you speak and be optimally verbose
Rule 4: Max indent per method should be 2, in case of exceptions 3
Rule 5: Avoid creating god object and long methods
Rule 6: Keep the method in one place, inject the class and call it, DRY
Rule 7: Avoid in-line comments (comment with code), put comments in the method doc
This document discusses Test Driven Development (TDD). It defines TDD, outlines the TDD process which involves writing tests first and then code to pass the tests, and emphasizes refactoring. Benefits of TDD include improved code quality, reduced bugs, and serving as documentation. Key TDD terms and libraries like JUnit and Mockito are explained. Continuous Integration (CI) is also discussed as it automates testing and builds when code is committed.
The document discusses principles and best practices for writing clean code, including using meaningful names, separating commands and queries, avoiding repetition, using exceptions instead of return codes, and following object-oriented principles like polymorphism instead of switch statements on objects. It provides examples of good and bad code for concepts like single responsibility, primitive obsession, and refused bequest. The overall goal is to write code that is readable, maintainable, and extendable.
The document discusses the principles of clean code as outlined in the book "Clean Code" by Robert C. Martin. It covers topics like meaningful names, comments, functions, objects and data structures, error handling, and unit tests. The goal of clean code is to produce readable, maintainable code through practices like breaking code into small, single-purpose functions and hiding implementation details in objects.
The document discusses refactoring tips provided by Martin Fowler. It defines refactoring as improving the internal structure of software without changing its external behavior. It provides examples of common refactoring techniques like extract method, inline method, move method, and consolidate conditional expressions. The goal of refactoring is to improve code quality by making software easier to understand and modify over time.
The document discusses the principles of clean architecture. It states that clean architecture aims to minimize human effort required to build and maintain software systems. It emphasizes that the core of an application should be its use cases rather than technical details like databases or frameworks. The architecture should clearly communicate the intent of the system. It also notes that dependencies should flow inward from outer layers like interfaces to inner layers containing core business logic and entities.
This document discusses principles and best practices for writing clean code. It defines clean code as code that works, is easy to read, understand and extend. It emphasizes writing code for other developers who will maintain it. Some key points include writing small, focused methods with meaningful names; avoiding duplicated code; using exceptions appropriately; formatting code consistently; and writing thorough automated tests. The overall goal is to communicate intent in the code as clearly as possible through these practices.
This document discusses code standards and best practices for writing maintainable code. It emphasizes the importance of code organization, documentation, naming conventions, indentation, brace styles, commenting, consistency, and readability. Specific guidelines are provided for naming conventions, indentation, brace styles, and commenting. The document stresses choosing and adhering to coding standards to promote uniformity and minimize issues when collaborating on projects.
Every project has a development standard.
Sometimes the standard is “if it was hard to write, it should be hard to maintain.”
Developing, and following, a corporate Best Practices standard will lead to continuity, maintainability, robustness, and pride.
This document provides an overview of test-driven development (TDD). It defines TDD as a technique for building software where tests are written before code to guide development. The key aspects of TDD covered are:
- Writing tests first before code, which helps improve design and ensures tests are written.
- The TDD mantra of Red-Green-Refactor, where tests initially fail (Red), code is written to pass tests (Green), then code is refactored to improve design.
- An example case study of a large Java project developed using TDD that has over 20,000 lines of unit tests providing over 90% test coverage.
Slides of the talk held at JEEConf, Kiev and jPrime, Sofia. A personal view on the classic topics from the Uncle Bob's Clean Code bible, with some personal additions and tips&tricks. This topic actually represents the core of the training sessions that I provide as an independent trainer (www.victorrentea.ro)
The document discusses principles of clean code, beginning with definitions of clean code from various authors. It outlines key principles like the single responsibility principle and open/closed principle. It then covers sections on meaningful naming, functions, and classes. For functions, it recommends they be small, do one thing, avoid flag arguments, and have no side effects. For classes, it advocates for small size, encapsulation, high cohesion and low coupling following the single responsibility principle.
clean code book summary - uncle bob - English versionsaber tabatabaee
The document provides guidance on writing clean code based on the book "Clean Code" by Robert Cecil Martin. Some of the key points discussed include:
- Functions should do one thing and do it well, with a single level of abstraction and no side effects. They should fit on a screen.
- Names should be meaningful, avoid abbreviations, and use consistent vocabulary. Class names should be nouns and method names should be verbs.
- Code formatting is important for readability. Classes should not exceed 200 lines, functions a single screen. Variables should be declared near use.
- Comments should only explain why unusual decisions were made, not what the code does. Avoid commented out code or redundant comments
The document discusses clean coding practices for Java developers. It covers topics such as choosing meaningful names for variables, methods, and classes; writing code that is easy for others to understand; breaking methods down into single logical steps; and using fluent APIs to make code more readable. The presentation provides examples of clean code and ways to refactor code to follow best practices.
This document discusses principles of clean code based on the book "Clean Code" by Robert C. Martin. It provides examples of good and bad practices for naming variables and functions, structuring functions, using comments, and other topics. Key points include using meaningful names, keeping functions small and focused on a single task, avoiding deeply nested code and long argument lists, commenting to explain intent rather than state the obvious, and other guidelines for writing clean, readable code.
Presentación para la charla sobre el libro de Robert C. Martin, Clean Code.
Esta presentación la impartí en CyLicon Valley, aquí tenéis el video con el audio de la charla => https://www.youtube.com/watch?v=1Fss1jBfc3g
This document discusses various code quality tools such as FindBugs, PMD, and Checkstyle. It provides information on what each tool is used for, how to install plugins for them in Eclipse, and how to configure them for use with Ant builds. FindBugs looks for potential bugs in Java bytecode. PMD scans source code for coding mistakes, dead code, complicated expressions, and duplicate code. Checkstyle checks that code complies with coding style rules. The document explains how to download and configure each tool so it can be run from Eclipse or as part of an Ant build.
4 Nisan 2015 tarihinde Kadir Has Üniversitesi'nde yapılan 9. Yazılım Teknolojileri Seminer etkinliğinde Eralp Erat'ın yaptığı TDD (Test Driven Design) sunumu
The document discusses GitLab CI/CD, an overview of the types of pipelines in GitLab including how they are defined and can group jobs. It also mentions manual actions, multi-project pipeline graphs, and security on protected branches. Additional topics covered include review apps and environments, application performance monitoring, next steps such as moving from dev to devops, how everyone can contribute to GitLab, and current job openings.
SonarQube is a tool that enables continuous inspection of code quality. It analyzes code for bugs, vulnerabilities, and code smells based on configured rules. The analysis is integrated into development pipelines so that quality feedback is immediately available. SonarQube provides metrics on key aspects of quality like technical debt, bugs, code coverage, and duplications to help teams improve their code. It supports over 25 programming languages and has extensible plugin architecture.
The document discusses coding standards and guidelines for developers to follow. It recommends limiting lines of code to 20 lines per function, writing comments before code, using PascalCase for class and method names and camelCase for variables, and giving functions, classes and variables meaningful names. Developers should not use single character variable names or underscores for local variables, and should prefix boolean variables with "is". Namespace names should follow a standard pattern of company, product, top and bottom level modules. Formatting and readability of code is also important. Future sessions will cover additional coding standards, tools to improve practices, and packaging programs.
This document compares the Kotlin and Swift programming languages. It provides an overview of key features of each language such as variables, functions, classes, inheritance, protocols/traits, enums, null safety, type checks and extensions. It also includes code examples to illustrate similarities and differences between the two languages. The document concludes with a comparison of other features and a diagram showing how each language fits into a typical mobile application architecture.
San Francisco Software Craftsmanship Meetup
Test Driven Developers Bay Area Meetup
TDD Flow: The Mantra in Action” is a talk + hands-on about the mantra of TDD and its core patterns. Here are some questions for this talk: What is TDD? How to write a good test that fails? How to write code enough to make the test pass? How to remove duplication? How to refactor code? How to create clean code? Is TDD about testing or design? How small should a test be? Should I only write unit tests? Should I estimate TDD? How to use TDD with other agile methods like Scrum, Kanban or BDD? And finally, how to flow in TDD?
This document provides an introduction to the Python programming language. It covers Python's background, syntax, types, operators, control flow, functions, classes, tools, and IDEs. Key points include that Python is a multi-purpose, object-oriented language that is interpreted, strongly and dynamically typed. It focuses on readability and has a huge library of modules. Popular Python IDEs include Emacs, Vim, Komodo, PyCharm, and Eclipse.
Refactoring Applications using SOLID PrinciplesSteven Smith
We’ve all heard about well-designed software projects, where things aren’t (yet) a big ball of mud that’s painful to work with, but many of us aren’t lucky enough to work on these. Nor is it an option for us to get to start a brand new “greenfield” project, where we can leave behind the legacy of spaghetti code and technical debt our current project might have.
But there is hope! By applying refactoring steps based on SOLID principles of object oriented design, we can reduce the technical debt of our existing application, improve our code quality, and hopefully make our application more enjoyable and productive to work with.
In this session, we’ll briefly introduce the SOLID principles and several design patterns, and then we’ll apply these principles and patterns by improving the design of an existing application through several refactoring steps.
The document summarizes key concepts from the book "Clean Code" by Robert C. Martin. It discusses how to structure code for readability through use of descriptive names, single responsibility principle, and minimal arguments. It also covers test-driven development principles like writing failing tests first and maintaining tests. The document advocates organizing code for change and keeping it modular, simple, and focused through refactoring.
The document discusses clean code and defines it as code that is simple, direct, and readable. It provides definitions of clean code from experts like Bjarne Stroustrup, Grady Booch, Dave Thomas, Ron Jeffries, and Robert Martin. Clean code is code that can be easily understood by other developers, has tests, meaningful names, minimal dependencies, and expresses design ideas clearly. The document emphasizes that code readability is more important than writability since code is read much more often than written.
This document discusses code standards and best practices for writing maintainable code. It emphasizes the importance of code organization, documentation, naming conventions, indentation, brace styles, commenting, consistency, and readability. Specific guidelines are provided for naming conventions, indentation, brace styles, and commenting. The document stresses choosing and adhering to coding standards to promote uniformity and minimize issues when collaborating on projects.
Every project has a development standard.
Sometimes the standard is “if it was hard to write, it should be hard to maintain.”
Developing, and following, a corporate Best Practices standard will lead to continuity, maintainability, robustness, and pride.
This document provides an overview of test-driven development (TDD). It defines TDD as a technique for building software where tests are written before code to guide development. The key aspects of TDD covered are:
- Writing tests first before code, which helps improve design and ensures tests are written.
- The TDD mantra of Red-Green-Refactor, where tests initially fail (Red), code is written to pass tests (Green), then code is refactored to improve design.
- An example case study of a large Java project developed using TDD that has over 20,000 lines of unit tests providing over 90% test coverage.
Slides of the talk held at JEEConf, Kiev and jPrime, Sofia. A personal view on the classic topics from the Uncle Bob's Clean Code bible, with some personal additions and tips&tricks. This topic actually represents the core of the training sessions that I provide as an independent trainer (www.victorrentea.ro)
The document discusses principles of clean code, beginning with definitions of clean code from various authors. It outlines key principles like the single responsibility principle and open/closed principle. It then covers sections on meaningful naming, functions, and classes. For functions, it recommends they be small, do one thing, avoid flag arguments, and have no side effects. For classes, it advocates for small size, encapsulation, high cohesion and low coupling following the single responsibility principle.
clean code book summary - uncle bob - English versionsaber tabatabaee
The document provides guidance on writing clean code based on the book "Clean Code" by Robert Cecil Martin. Some of the key points discussed include:
- Functions should do one thing and do it well, with a single level of abstraction and no side effects. They should fit on a screen.
- Names should be meaningful, avoid abbreviations, and use consistent vocabulary. Class names should be nouns and method names should be verbs.
- Code formatting is important for readability. Classes should not exceed 200 lines, functions a single screen. Variables should be declared near use.
- Comments should only explain why unusual decisions were made, not what the code does. Avoid commented out code or redundant comments
The document discusses clean coding practices for Java developers. It covers topics such as choosing meaningful names for variables, methods, and classes; writing code that is easy for others to understand; breaking methods down into single logical steps; and using fluent APIs to make code more readable. The presentation provides examples of clean code and ways to refactor code to follow best practices.
This document discusses principles of clean code based on the book "Clean Code" by Robert C. Martin. It provides examples of good and bad practices for naming variables and functions, structuring functions, using comments, and other topics. Key points include using meaningful names, keeping functions small and focused on a single task, avoiding deeply nested code and long argument lists, commenting to explain intent rather than state the obvious, and other guidelines for writing clean, readable code.
Presentación para la charla sobre el libro de Robert C. Martin, Clean Code.
Esta presentación la impartí en CyLicon Valley, aquí tenéis el video con el audio de la charla => https://www.youtube.com/watch?v=1Fss1jBfc3g
This document discusses various code quality tools such as FindBugs, PMD, and Checkstyle. It provides information on what each tool is used for, how to install plugins for them in Eclipse, and how to configure them for use with Ant builds. FindBugs looks for potential bugs in Java bytecode. PMD scans source code for coding mistakes, dead code, complicated expressions, and duplicate code. Checkstyle checks that code complies with coding style rules. The document explains how to download and configure each tool so it can be run from Eclipse or as part of an Ant build.
4 Nisan 2015 tarihinde Kadir Has Üniversitesi'nde yapılan 9. Yazılım Teknolojileri Seminer etkinliğinde Eralp Erat'ın yaptığı TDD (Test Driven Design) sunumu
The document discusses GitLab CI/CD, an overview of the types of pipelines in GitLab including how they are defined and can group jobs. It also mentions manual actions, multi-project pipeline graphs, and security on protected branches. Additional topics covered include review apps and environments, application performance monitoring, next steps such as moving from dev to devops, how everyone can contribute to GitLab, and current job openings.
SonarQube is a tool that enables continuous inspection of code quality. It analyzes code for bugs, vulnerabilities, and code smells based on configured rules. The analysis is integrated into development pipelines so that quality feedback is immediately available. SonarQube provides metrics on key aspects of quality like technical debt, bugs, code coverage, and duplications to help teams improve their code. It supports over 25 programming languages and has extensible plugin architecture.
The document discusses coding standards and guidelines for developers to follow. It recommends limiting lines of code to 20 lines per function, writing comments before code, using PascalCase for class and method names and camelCase for variables, and giving functions, classes and variables meaningful names. Developers should not use single character variable names or underscores for local variables, and should prefix boolean variables with "is". Namespace names should follow a standard pattern of company, product, top and bottom level modules. Formatting and readability of code is also important. Future sessions will cover additional coding standards, tools to improve practices, and packaging programs.
This document compares the Kotlin and Swift programming languages. It provides an overview of key features of each language such as variables, functions, classes, inheritance, protocols/traits, enums, null safety, type checks and extensions. It also includes code examples to illustrate similarities and differences between the two languages. The document concludes with a comparison of other features and a diagram showing how each language fits into a typical mobile application architecture.
San Francisco Software Craftsmanship Meetup
Test Driven Developers Bay Area Meetup
TDD Flow: The Mantra in Action” is a talk + hands-on about the mantra of TDD and its core patterns. Here are some questions for this talk: What is TDD? How to write a good test that fails? How to write code enough to make the test pass? How to remove duplication? How to refactor code? How to create clean code? Is TDD about testing or design? How small should a test be? Should I only write unit tests? Should I estimate TDD? How to use TDD with other agile methods like Scrum, Kanban or BDD? And finally, how to flow in TDD?
This document provides an introduction to the Python programming language. It covers Python's background, syntax, types, operators, control flow, functions, classes, tools, and IDEs. Key points include that Python is a multi-purpose, object-oriented language that is interpreted, strongly and dynamically typed. It focuses on readability and has a huge library of modules. Popular Python IDEs include Emacs, Vim, Komodo, PyCharm, and Eclipse.
Refactoring Applications using SOLID PrinciplesSteven Smith
We’ve all heard about well-designed software projects, where things aren’t (yet) a big ball of mud that’s painful to work with, but many of us aren’t lucky enough to work on these. Nor is it an option for us to get to start a brand new “greenfield” project, where we can leave behind the legacy of spaghetti code and technical debt our current project might have.
But there is hope! By applying refactoring steps based on SOLID principles of object oriented design, we can reduce the technical debt of our existing application, improve our code quality, and hopefully make our application more enjoyable and productive to work with.
In this session, we’ll briefly introduce the SOLID principles and several design patterns, and then we’ll apply these principles and patterns by improving the design of an existing application through several refactoring steps.
The document summarizes key concepts from the book "Clean Code" by Robert C. Martin. It discusses how to structure code for readability through use of descriptive names, single responsibility principle, and minimal arguments. It also covers test-driven development principles like writing failing tests first and maintaining tests. The document advocates organizing code for change and keeping it modular, simple, and focused through refactoring.
The document discusses clean code and defines it as code that is simple, direct, and readable. It provides definitions of clean code from experts like Bjarne Stroustrup, Grady Booch, Dave Thomas, Ron Jeffries, and Robert Martin. Clean code is code that can be easily understood by other developers, has tests, meaningful names, minimal dependencies, and expresses design ideas clearly. The document emphasizes that code readability is more important than writability since code is read much more often than written.
Clan code is extremely essential to build scalable application which can be maintained quite easily and improved further
Slide was prepared with contribution to my colleague
and i thank them for the help!
Driving application development through behavior driven developmentEinar Ingebrigtsen
This document discusses Behavior Driven Development (BDD) and how it can be used to drive application development. It introduces BDD, focusing on behaviors of the system rather than tests. It discusses key aspects of BDD like Gherkin, units, test doubles, writing testable code, frameworks like SpecFlow and recommended reading. The overall message is that BDD changes the way software is developed by shifting the focus to behaviors and improving collaboration.
This document discusses Test-Driven Development (TDD). It defines TDD as writing unit tests before writing any production code. TDD helps ensure code is consistently refactored for better design. The document outlines the TDD process of writing a test, seeing it fail, writing code to pass the test, then refactoring. It discusses using TDD with legacy code by refactoring code to be testable. Sample unit tests are provided to demonstrate testing default constructor values. Benefits of TDD include better code design, earlier defect detection, and fewer defects in production releases.
Code smells and Other Malodorous Software OdorsClint Edmonson
This document discusses code smells, which are surface indications in source code that typically correspond to deeper problems in the system. It defines several common code smells such as duplicate code, large methods, magic numbers, dead code, and speculative code. The document provides explanations of these smells and recommendations for addressing them, such as extracting duplicated code into methods, breaking large classes into smaller focused classes, and avoiding checking in experimental code. It notes that code smells often arise from issues like haste, apathy, and ignorance when developing code.
What is practice, Examples, Best practices that developers should follow. Useful tools that every developer should carry and useful GitHub repositories.
Second "code school lesson" for Eurosport's developers.
1. Refactoring : when? why? how?
2. Single Responsability
3. Practical case : clean architecture.
This document discusses test driven development (TDD) and automation for PHP projects. It covers what TDD is, why it should be done, where tests should run, who should adopt TDD, and why unit testing, code coverage, code sniffing and Selenium are important. It also discusses tools for PHP TDD like Xdebug, PHPUnit, PHP_CodeSniffer and IDEs. The document provides examples of writing test cases with the red-green-refactor process and integrating TDD into a build system with automated testing on every code change.
This document summarizes key principles for writing clean code as outlined in the book "Clean Code" by Robert C. Martin. It discusses ideas like writing code that is easy to read and understand through use of meaningful names, small functions that do one thing well, and avoiding duplication. It also covers principles for object-oriented design like encapsulation, organization for change, and separation of concerns. Testing philosophies like test-driven development and ensuring tests are fast, independent, repeatable, self-validating, and timely are also emphasized. The overall message is that writing clean code requires attention to structure, naming, formatting and testing to produce software that is simple, well-organized and a pleasure to maintain.
A presentation on PHP's position in the enterprise, its past & present, how to get ready for developing for enterprise.
Inspired by Ivo Jansch's "PHP in the real wolrd" presentation.
Presented at SoftExpo 2010, Dhaka, Bangladesh.
This document discusses test driven development (TDD). It begins by explaining the basic TDD process of writing a failing test, getting it to compile, making it pass without changing existing code, and then refactoring. It outlines some benefits of TDD like improved code quality and confidence in changes. It also notes some challenges like additional overhead and keeping test code clean. Overall, it argues that while TDD requires proper implementation, it can help produce higher quality code with fewer bugs.
The document discusses tips for being a good developer, including writing good code through principles like the single responsibility principle, DRY principle, and design patterns. It emphasizes writing clean, readable code through practices like object-oriented programming, refactoring, and code documentation. Being a good developer also means having soft skills like admitting limitations, learning from others, teamwork, communication, and embracing failure while taking risks and learning new technologies.
This document discusses continuous integration in a PHP context. Continuous integration is a software development practice where developers regularly merge their code changes into a central repository. This allows the integration of code changes to be tested and identified early if issues arise. The benefits are less time spent fixing bugs and integration issues. Tools mentioned that can help with continuous integration for PHP projects include PHPUnit, Selenium, PHPMD, PDepend, PHP_CodeSniffer, phpUnderControl, Xinc, Hudson and Bamboo. Regular integration and testing of all code changes is important for reducing project risks.
Test driven development involves writing tests before writing code to make the tests pass. This ensures code is built to satisfy explicit requirements. The TDD process is: write a failing test, write code to pass the test, refactor code. This improves quality by preventing defects and ensuring code is maintainable through extensive automated testing. Acceptance TDD applies this process on a system level to build the right functionality.
Joe Cisar - Everything I Know About TDD - Agile Midwest 2019Jason Tice
The document discusses test-driven development (TDD). TDD is a software development process where test cases are created to specify requirements before code is written to pass those tests. This ensures code meets requirements. Benefits of TDD include fewer bugs due to comprehensive testing, and ability to refactor code without breaking functionality. The document provides examples of different types of tests and outlines best practices for getting started with TDD.
SubmitJS: Is react + redux + typescript a good combination? Dmytro BesedaBinary Studio
Binary Studio
See full record of a talk given at our javascript meetup here https://www.youtube.com/watch?v=8B3dBDA6W-U&list=PLXsWM8PhzhwRoD91MzCWn-INKkgoJBXxV&index=2
Hi I’m Cris, iOS Developer in KLabCyscorpions. In this post, I want to share with you my presentation on Code Review guidelines for iOS.
But, what is Code Review?
According to Wikipedia:
“Code Review is systematic examination (often known as peer review) of computer source code. It is intended to find and fix mistakes overlooked in the initial development phase, improving both the overall quality of software and the developers’ skills. Reviews are done in various forms such as pair programming, informal walkthroughs, and formal inspections.”
Want to review code? Then First things first! For you to review code effectively, you need the basic know-how of reviewing code as both the developer and the reviewer. These slides will give some guidelines on how to think in both these roles when reviewing code.
Custom Coded Projects - When picking up a project you have many choices to make. Do you go for a premium theme and already builded plugins or will you write parts yourself. I will discuss what impacts custom building a project can have. I will focus on time, cost and speed to help you out with your decision making with future projects.
- WordPress is used on 26.6% of all websites worldwide as of 2016, showing steady growth each year.
- A security audit of popular WordPress plugins found 118 instances of vulnerabilities across 58 plugins, demonstrating the ongoing need to improve WordPress security.
- There are several steps site owners can take to harden WordPress security, such as limiting login attempts, enforcing SSL, moving files like wp-config.php, and using server-level protections including fail2ban, Nginx configurations, and a web application firewall. External services like Cloudflare and Sucuri can also help monitor and protect sites.
I have contributed since 2009 to WordPress and related projects. I have done some great things for WordPress like rewriting the image manipulation API and leading GlotPress for a long while. But It also lead to some disagreements which had an impact.
It all started with an idea when it got announced and shared by Kaspars Dambis. He wrote a blog post about it and I really started digging the idea even more. During this talk I will discuss new options Apple TV gives developers like us. Showing the power of the REST API and the XML template format of Apple to build a WooCommerce AppleTV app.
The moment my site got hacked - WordCamp SofiaMarko Heijnen
You always think it will never happen to you but when it does, it’s all hands on deck. My personal site was almost hacked and since then I actively looked at what I could improve. During this talk I will talk what I had before and show all the improvements I made since then. It will be a mixed of using using the existing tools and my own creation in managing my sites.
Online zie je veel tips om je WordPress site te beveiligen. Vaak raden ze hiervoor een WordPress plugin aan. Dit is vaak niet de juiste oplossing en tijdens deze presentatie laat ik zien hoe ik het zelf doe. Dit gaat van hoe je site optimaal beveiligd tot hoe je jouw site in de gaten kan houden.
You always think it will never happen to you but when it does, it’s all hands on deck. My personal site was almost hacked and since then I actively looked at what I could improve. During this talk I will talk what I had before and show all the improvements I made since then. It will be a mixed of using using the existing tools and my own creation in managing my sites.
Most of us started running their first site on shared hosting but over time you want more out of it. After some bad experiences, I decided to move to a VPS and do it myself. In the beginning I made a few mistakes but since then things grow that my sites are now running on 6 servers. During this talk I will discuss how my site has grown to be more complex in the last couple of years and how it looks now. This will include all the mistakes I made.
Being a WordPress developer means that our main programming language is PHP. Which works for building websites but not for running tasks. In this talk I will share my experience using Node.js as a platform to build on. Explaining why I have chosen for Node.js and show you how I used Node.js to build microservices that are supporting my WordPress projects.
This document discusses ways to detect security issues on a WordPress site and server. It recommends using tools like ModSecurity, fail2ban, Apticron, and Apt-dater to monitor for updates, failed login attempts, and other security events. It also proposes building a WordPress plugin called WP Central that would aggregate security data from all sites and servers and provide a central dashboard. The plugin would monitor files, permissions, login attempts, and perform checksum scans to detect any changes or additions.
Marko Heijnen discussed several ways to extend WordPress, including hooks, drop-ins, pluggable functions, and pluggable classes. He demonstrated wpcentral.io, which collects WordPress usage data, and opensesh.org, a conference platform built with Node.js. He explained how to build extensions for the future by future-proofing code and looking at new technologies like Node.js.
Let's create a multilingual site in WordPressMarko Heijnen
- The document discusses creating multilingual WordPress sites and tools for translation.
- It covers the current state of WordPress translations, how to make code translatable, creating language files, and using GlotPress for translation management.
- New features of GlotPress that are helping with translation are highlighted, including the locale page, glossary, notifications, and profile pages.
This document summarizes Marko Heijnen's talk on bootstrapping a WordPress plugin using automation. It discusses setting up the basic files and structure for a plugin, including internationalization, version control and compiling assets. It also covers automating common tasks like minification, validation and testing through Grunt plugins. Grunt is presented as a JavaScript task runner that can be used to define and run repetitive tasks like compressing files, validating code and deployments. Examples are provided for configuring Grunt to create POT files for internationalization, download translations from GlotPress and perform other automated tasks.
The development and future of GlotPressMarko Heijnen
A talk about the history, the current status en future of GlotPress. GlotPress is a collaborative, web-based software translation tool used by WordPress and related projects.
At WordCamp Norway I presented about why Javascript matters when developing for WordPress. The amount of Javascript grows and it's time that developers look more into Javascript.
The focus is around the example I build for WordSesh to show what you can do with Javascript and Node.js
This document summarizes the code history of WordPress from its founding in 2003 to the present. It discusses major releases, contributors, added features like post meta and plugins, tools used for development like Git and unit testing, and the future direction of new APIs. The timeline shows steady growth from a few early contributors to over 200 today, with major releases every 6-12 months adding significant new functionality that maintains backwards compatibility.
The document discusses best practices for building WordPress plugins, including improving one's workflow with version control and text editors, understanding WordPress code structure and APIs, following coding standards, defining a plugin's focus and structure, and testing plugins. It also provides examples from the speaker's own plugins and mistakes made. The speaker advocates investing in one's skills and producing well-coded, unique plugins that address user experience through standards compliance and robust testing.
Perfect your images using WordPress - WordCamp Europe 2013Marko Heijnen
This document summarizes a presentation given by Mike Schroder and Marko Heijnen at WordCamp Europe 2013 about image manipulation in WordPress. It discusses how image handling was abstracted in WordPress through the WP_Image_Editor class, which provides a centralized way to read, manipulate, save, and stream images. Examples are given showing how to use WP_Image_Editor to perform common image editing tasks like resizing and cropping. Additional resources and plugins are also listed that extend WordPress's image editing capabilities.
This document discusses changes to media handling in WordPress 3.5, including a new media manager, ability for multiple galleries, drag and drop functionality, and backend API rewrite. It notes some issues with the new system and proposes extensions like media tags, faster image insertion, and media folders. It also covers using the WP_Image_Editor class to programmatically edit images and plugins that improve image handling.
Semantic Cultivators : The Critical Future Role to Enable AIartmondano
By 2026, AI agents will consume 10x more enterprise data than humans, but with none of the contextual understanding that prevents catastrophic misinterpretations.
Andrew Marnell: Transforming Business Strategy Through Data-Driven InsightsAndrew Marnell
With expertise in data architecture, performance tracking, and revenue forecasting, Andrew Marnell plays a vital role in aligning business strategies with data insights. Andrew Marnell’s ability to lead cross-functional teams ensures businesses achieve sustainable growth and operational excellence.
#StandardsGoals for 2025: Standards & certification roundup - Tech Forum 2025BookNet Canada
Book industry standards are evolving rapidly. In the first part of this session, we’ll share an overview of key developments from 2024 and the early months of 2025. Then, BookNet’s resident standards expert, Tom Richardson, and CEO, Lauren Stewart, have a forward-looking conversation about what’s next.
Link to recording, transcript, and accompanying resource: https://bnctechforum.ca/sessions/standardsgoals-for-2025-standards-certification-roundup/
Presented by BookNet Canada on May 6, 2025 with support from the Department of Canadian Heritage.
Enhancing ICU Intelligence: How Our Functional Testing Enabled a Healthcare I...Impelsys Inc.
Impelsys provided a robust testing solution, leveraging a risk-based and requirement-mapped approach to validate ICU Connect and CritiXpert. A well-defined test suite was developed to assess data communication, clinical data collection, transformation, and visualization across integrated devices.
Generative Artificial Intelligence (GenAI) in BusinessDr. Tathagat Varma
My talk for the Indian School of Business (ISB) Emerging Leaders Program Cohort 9. In this talk, I discussed key issues around adoption of GenAI in business - benefits, opportunities and limitations. I also discussed how my research on Theory of Cognitive Chasms helps address some of these issues
Dev Dives: Automate and orchestrate your processes with UiPath MaestroUiPathCommunity
This session is designed to equip developers with the skills needed to build mission-critical, end-to-end processes that seamlessly orchestrate agents, people, and robots.
📕 Here's what you can expect:
- Modeling: Build end-to-end processes using BPMN.
- Implementing: Integrate agentic tasks, RPA, APIs, and advanced decisioning into processes.
- Operating: Control process instances with rewind, replay, pause, and stop functions.
- Monitoring: Use dashboards and embedded analytics for real-time insights into process instances.
This webinar is a must-attend for developers looking to enhance their agentic automation skills and orchestrate robust, mission-critical processes.
👨🏫 Speaker:
Andrei Vintila, Principal Product Manager @UiPath
This session streamed live on April 29, 2025, 16:00 CET.
Check out all our upcoming Dev Dives sessions at https://community.uipath.com/dev-dives-automation-developer-2025/.
Linux Support for SMARC: How Toradex Empowers Embedded DevelopersToradex
Toradex brings robust Linux support to SMARC (Smart Mobility Architecture), ensuring high performance and long-term reliability for embedded applications. Here’s how:
• Optimized Torizon OS & Yocto Support – Toradex provides Torizon OS, a Debian-based easy-to-use platform, and Yocto BSPs for customized Linux images on SMARC modules.
• Seamless Integration with i.MX 8M Plus and i.MX 95 – Toradex SMARC solutions leverage NXP’s i.MX 8 M Plus and i.MX 95 SoCs, delivering power efficiency and AI-ready performance.
• Secure and Reliable – With Secure Boot, over-the-air (OTA) updates, and LTS kernel support, Toradex ensures industrial-grade security and longevity.
• Containerized Workflows for AI & IoT – Support for Docker, ROS, and real-time Linux enables scalable AI, ML, and IoT applications.
• Strong Ecosystem & Developer Support – Toradex offers comprehensive documentation, developer tools, and dedicated support, accelerating time-to-market.
With Toradex’s Linux support for SMARC, developers get a scalable, secure, and high-performance solution for industrial, medical, and AI-driven applications.
Do you have a specific project or application in mind where you're considering SMARC? We can help with Free Compatibility Check and help you with quick time-to-market
For more information: https://www.toradex.com/computer-on-modules/smarc-arm-family
This is the keynote of the Into the Box conference, highlighting the release of the BoxLang JVM language, its key enhancements, and its vision for the future.
AI and Data Privacy in 2025: Global TrendsInData Labs
In this infographic, we explore how businesses can implement effective governance frameworks to address AI data privacy. Understanding it is crucial for developing effective strategies that ensure compliance, safeguard customer trust, and leverage AI responsibly. Equip yourself with insights that can drive informed decision-making and position your organization for success in the future of data privacy.
This infographic contains:
-AI and data privacy: Key findings
-Statistics on AI data privacy in the today’s world
-Tips on how to overcome data privacy challenges
-Benefits of AI data security investments.
Keep up-to-date on how AI is reshaping privacy standards and what this entails for both individuals and organizations.
AI Changes Everything – Talk at Cardiff Metropolitan University, 29th April 2...Alan Dix
Talk at the final event of Data Fusion Dynamics: A Collaborative UK-Saudi Initiative in Cybersecurity and Artificial Intelligence funded by the British Council UK-Saudi Challenge Fund 2024, Cardiff Metropolitan University, 29th April 2025
https://alandix.com/academic/talks/CMet2025-AI-Changes-Everything/
Is AI just another technology, or does it fundamentally change the way we live and think?
Every technology has a direct impact with micro-ethical consequences, some good, some bad. However more profound are the ways in which some technologies reshape the very fabric of society with macro-ethical impacts. The invention of the stirrup revolutionised mounted combat, but as a side effect gave rise to the feudal system, which still shapes politics today. The internal combustion engine offers personal freedom and creates pollution, but has also transformed the nature of urban planning and international trade. When we look at AI the micro-ethical issues, such as bias, are most obvious, but the macro-ethical challenges may be greater.
At a micro-ethical level AI has the potential to deepen social, ethnic and gender bias, issues I have warned about since the early 1990s! It is also being used increasingly on the battlefield. However, it also offers amazing opportunities in health and educations, as the recent Nobel prizes for the developers of AlphaFold illustrate. More radically, the need to encode ethics acts as a mirror to surface essential ethical problems and conflicts.
At the macro-ethical level, by the early 2000s digital technology had already begun to undermine sovereignty (e.g. gambling), market economics (through network effects and emergent monopolies), and the very meaning of money. Modern AI is the child of big data, big computation and ultimately big business, intensifying the inherent tendency of digital technology to concentrate power. AI is already unravelling the fundamentals of the social, political and economic world around us, but this is a world that needs radical reimagining to overcome the global environmental and human challenges that confront us. Our challenge is whether to let the threads fall as they may, or to use them to weave a better future.
The Evolution of Meme Coins A New Era for Digital Currency ppt.pdfAbi john
Analyze the growth of meme coins from mere online jokes to potential assets in the digital economy. Explore the community, culture, and utility as they elevate themselves to a new era in cryptocurrency.
What is Model Context Protocol(MCP) - The new technology for communication bw...Vishnu Singh Chundawat
The MCP (Model Context Protocol) is a framework designed to manage context and interaction within complex systems. This SlideShare presentation will provide a detailed overview of the MCP Model, its applications, and how it plays a crucial role in improving communication and decision-making in distributed systems. We will explore the key concepts behind the protocol, including the importance of context, data management, and how this model enhances system adaptability and responsiveness. Ideal for software developers, system architects, and IT professionals, this presentation will offer valuable insights into how the MCP Model can streamline workflows, improve efficiency, and create more intuitive systems for a wide range of use cases.
Designing Low-Latency Systems with Rust and ScyllaDB: An Architectural Deep DiveScyllaDB
Want to learn practical tips for designing systems that can scale efficiently without compromising speed?
Join us for a workshop where we’ll address these challenges head-on and explore how to architect low-latency systems using Rust. During this free interactive workshop oriented for developers, engineers, and architects, we’ll cover how Rust’s unique language features and the Tokio async runtime enable high-performance application development.
As you explore key principles of designing low-latency systems with Rust, you will learn how to:
- Create and compile a real-world app with Rust
- Connect the application to ScyllaDB (NoSQL data store)
- Negotiate tradeoffs related to data modeling and querying
- Manage and monitor the database for consistently low latencies
HCL Nomad Web – Best Practices und Verwaltung von Multiuser-Umgebungenpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-nomad-web-best-practices-und-verwaltung-von-multiuser-umgebungen/
HCL Nomad Web wird als die nächste Generation des HCL Notes-Clients gefeiert und bietet zahlreiche Vorteile, wie die Beseitigung des Bedarfs an Paketierung, Verteilung und Installation. Nomad Web-Client-Updates werden “automatisch” im Hintergrund installiert, was den administrativen Aufwand im Vergleich zu traditionellen HCL Notes-Clients erheblich reduziert. Allerdings stellt die Fehlerbehebung in Nomad Web im Vergleich zum Notes-Client einzigartige Herausforderungen dar.
Begleiten Sie Christoph und Marc, während sie demonstrieren, wie der Fehlerbehebungsprozess in HCL Nomad Web vereinfacht werden kann, um eine reibungslose und effiziente Benutzererfahrung zu gewährleisten.
In diesem Webinar werden wir effektive Strategien zur Diagnose und Lösung häufiger Probleme in HCL Nomad Web untersuchen, einschließlich
- Zugriff auf die Konsole
- Auffinden und Interpretieren von Protokolldateien
- Zugriff auf den Datenordner im Cache des Browsers (unter Verwendung von OPFS)
- Verständnis der Unterschiede zwischen Einzel- und Mehrbenutzerszenarien
- Nutzung der Client Clocking-Funktion
2. Marko Heijnen
• Lead developer of GlotPress
• Core contributor for WordPress
• Working for 1&1 as their
WordPress specialist
• Fan of new technologies
3. Quick note
This talk is not only for developers.
Knowing how code should look like is important to
judge it’s quality.
7. – Bjarne Stroustrup, inventor of C++
“I like my code be elegant and efficient”
“Clean code does one thing well”
Elegance
8. – Grady Booch, author of Object Oriented Analysis
and Design With Applications
“Clean code is simple and direct”
“Clean code reads like well-written prose”
Simple, direct, readable
9. – Dave Thomas, founder of OTI
“Clean code can be read”
“Clean code should be literate”
Literate
10. – Michael Feathers, author of Working Effectively with Legacy Code
“Clean code always looks like it was written by
someone who cares”
Care
11. – Ron Jeffries, author of Extreme Programming Installed
“No duplication, one thing, expressiveness, tiny
abstractions.”
Small, expressive, simple
12. – Ward Cunningham, inventor of Wiki, Fit, coinventor of eXtreme
Programming. Motive force behind Design Patterns
“You know you are working on clean code
when each routing you reads turns out to be
pretty much what you expected.”
What you expected
16. Meaningful names
• Classes should have a noun or noun phrase names but
should not be a verb
• Method names should have verb or verb phrase names
• Use descriptive names
17. The code
• Should be very small!
< 150 characters per line and < 20 lines
• Do one thing and do that right
• Limit it to one level of abstraction
• Reading code from top to bottom
• The ideal number of arguments for a function is zero
18. The code
• Don’t use flag arguments
• passing a boolean into a function
• Pass objects as a function argument to reduce the
arguments
• Have no side effect, does what is expected
• Don’t repeat yourself
• Only return data once
25. What does this mean for WordPress?
• Follow the WordPress coding standards
• A shared code base is an important aspect for clean code
• Have it prefix with something that is unique
26. What are the violations in WordPress
• A lot of global variables
• Functions/Methods should never echo
• Returning WP_Error instead of exceptions
• WP_DB
27. Last but not least
Test Driven Development: Unit Tests
28. The three laws of Test Driven Development
• First law
You may not write production code until you have written
a failing unit test
• Second law
You may not write more of a unit test than is sufficient to
fail, and not compiling is failing
• Third law
You may not write more production code than is sufficient
to pass the currently failing test
29. Unit tests is the best documentation of your code
It shows how you intended your code to be used
30. Keep test clean with the same standards as your
production code.
32. A single unit test should contain
• Single concept per test
• One assert per test is a good guideline
• Five other rules: F.I.R.S.T
• Fast
• Independent
• Repeatable
• Self-Validating
• Timely
34. Clean code & me
• I never studied Computer Science
• I do care about quality and structure
• I refuse to do quick wins or hacks
• Work together with others to become better
• Applying unit tests on existing projects
• A lot of refactoring and WTF moments
36. What I have learned from working
together with a Java developer
37. What I have learned from working
together with a Java developer
• Start applying all the things I discussed
• Using OOP more then just wrapping functions in a class
• Using a Wrapper / Decorator pattern
• Think more in advance how things should work
• And also think what could change