From f2eed5fed824241600ff69d7dbea8d0261e7ef53 Mon Sep 17 00:00:00 2001
From: olaru <olaru@rospace.com>
Date: Tue, 8 Sep 2026 10:53:49 +0300
Subject: [PATCH] Rewrite .md files

---
 .../listen-for-android-install-referrer.md    |   9 +-
 ...ers-in-the-same-app-for-the-same-action.md |  13 +-
 ...vider-bootstrap-modern-php-applications.md |  99 +++---
 ...ifecycle-for-a-mezzio-based-application.md |  99 +++---
 .../architecture/understanding-middleware.md  |  87 +++---
 .../best-practice/aptana-set-svn-keywords.md  |  13 +-
 ...security-in-dotkernel-headless-platform.md |  25 +-
 ...golden-rules-of-professional-php-coding.md |  24 +-
 .../htaccess-301-redirect-non-www-to-www.md   |   4 +-
 ...t-update-delete-statements-with-zend-db.md |  35 ++-
 .../sql-queries-using-zend-db-select.md       |  46 +--
 .../best-practice/subqueries-with-zend-db.md  |  13 +-
 .../svn-export-in-a-virtual-host.md           |  38 +--
 ...n-keywords-setup-in-php-ide-zend-studio.md |  17 +-
 .../using-like-wildcards-with-zend-db.md      |  47 +--
 ...urning-the-fetch-functions-from-zend-db.md |  55 ++--
 ...estamp-on-a-field-that-record-date-time.md |   9 +-
 ...inas-mvc-is-retiring-consider-it-solved.md |  25 +-
 ...r-15-handlers-in-dotkernel-applications.md |  28 +-
 ...-client-migration-from-postman-to-bruno.md | 121 ++++----
 .../api-endpoint-to-collect-client-errors.md  |  27 +-
 ...ntent-negotiation-in-dotkernel-rest-api.md | 111 +++----
 .../dotkernel-api-1-0-0-released.md           |  62 ++--
 ...dotkernel-api-client-side-authorization.md |  22 +-
 ...dotkernel-api-server-side-authorization.md |  71 +++--
 .../dotkernel-api-versus-laminas-api-tools.md |  28 +-
 ...ror-reporting-endpoint-in-dotkernel-api.md |  92 ++++--
 ...to-implement-mailchimp-in-dotkernel-api.md |  39 ++-
 ...openapi-implementation-in-dotkernel-api.md | 118 +++++---
 ...-cors-implementation-to-zend-expressive.md |  75 +++--
 ...g-layer-to-wurfl-in-dotkernel-using-apc.md |  29 +-
 ...poser-support-in-your-dotkernel-project.md |  91 +++---
 ...browser-detection-in-dotkernel-projects.md |  36 +--
 ...n-using-cookie-remember-me-in-dotkernel.md |  95 +++---
 ...through-bootstrap-of-non-existent-files.md |  15 +-
 ...ching-in-dotkernel-using-zend-framework.md |  48 ++-
 ...melcase-table-names-in-mysql-on-windows.md |  14 +-
 ...end-certified-engineers-zce-in-our-team.md |  12 +-
 .../configuring-the-cache-in-dotkernel.md     |  37 +--
 ...ade-easy-in-laminas-mezzio-applications.md |  58 ++--
 ...cting-mobile-devices-in-dotkernel-1-6-0.md |  49 +--
 ...able-wurfl-redirect-for-mobile-browsers.md |  13 +-
 ...ambiguation-dotkernel-1-and-dotkernel-3.md |  13 +-
 .../doctrine-cache-using-symfony-cache.md     | 110 ++++---
 ...ctrine-enum-implementation-in-dotkernel.md |  91 +++---
 ...ts-and-services-north-american-relaunch.md |  19 +-
 .../dotkernel/dotkernel-1-2-0-release.md      |  30 +-
 .../dotkernel/dotkernel-1-2-2-release.md      |  33 +-
 .../dotkernel/dotkernel-1-3-0-release.md      |  38 ++-
 .../dotkernel/dotkernel-1-3-2-release.md      |  40 +--
 .../dotkernel/dotkernel-1-5-0-released.md     |  39 ++-
 .../dotkernel/dotkernel-1-8-0-lts-released.md |  65 ++--
 ...ernel-1-8-1-upgrade-from-1-8-0-released.md |  21 +-
 .../dotkernel/dotkernel-coding-standard.md    |  38 ++-
 ...l-database-naming-conventions-for-mysql.md |  35 ++-
 ...o-microframework-and-laminas-components.md |  49 ++-
 ...-best-choice-for-your-presentation-site.md | 133 ++++----
 .../dotkernel/dotkernel-on-nginx.md           |  75 +++--
 ...nel-reserved-variable-names-for-caching.md |  64 ++--
 .../dotkernel/dotkernel-template-engine.md    |   6 +-
 .../dotkernel-version-1-0-in-action.md        |  34 ++-
 ...-connections-and-character-set-in-mysql.md |  20 +-
 .../geoip-city-removed-from-dotkernel.md      |  56 ++--
 .../geoip-ip-address-location-in-dotkernel.md |  48 ++-
 ...rrors-with-dot-errorhandler-and-dot-log.md | 106 +++----
 ...ghcharts-integration-in-dotkernel-1-6-0.md |  90 +++---
 ...o-group-log-files-by-date-using-dot-log.md | 145 ++++-----
 ...ase-with-zend-framework-zend-db-adapter.md |  19 +-
 .../how-to-use-alerts-in-dotkernel.md         |  82 +++--
 ...d-hashing-api-from-php-5-5-in-dotkernel.md |  48 ++-
 ...extension-in-zend-server-5-6-on-windows.md |  69 +++--
 ...p-extension-in-zend-server-6-on-windows.md |  24 +-
 ...ot-log-in-zend-expressive-and-dotkernel.md | 283 +++++-------------
 ...-upgrade-of-wurfl-xml-file-in-dotkernel.md |  28 +-
 ...ration-of-zend-framework-1-pear-channel.md |  39 ++-
 .../new-features-in-zend-framework-1-12.md    |  65 ++--
 ...tter-and-templates-for-zend-studio-10-1.md |  22 +-
 ...ing-admin-folder-with-htaccess-in-plesk.md |  24 +-
 ...as-mail-with-symfony-mailer-in-dot-mail.md |  99 +++---
 ...urfl-cloud-php-library-to-dotkernel-1-6.md |  29 +-
 ...sing-dot-email-component-and-zend-email.md |  47 +--
 .../dotkernel/templating-in-dotkernel3.md     |  19 +-
 public/md-articles/dotkernel/test-article.md  |   3 +
 ...ng-dotkernel-with-composer-dependencies.md |  90 +++---
 .../using-utf8-charset-in-dotkernel.md        |  33 +-
 ...fl-cloud-integration-in-dotkernel-1-6-0.md |  34 ++-
 ...api-license-incompatible-with-dotkernel.md |  41 ++-
 ...nd-framework-integration-into-dotkernel.md |  51 ++--
 ...th-and-zend-acl-integrated-in-dotkernel.md |  47 +--
 ...end-console-implementation-in-dotkernel.md |  25 +-
 ...rk-dropped-integration-of-wurfl-adapter.md |  16 +-
 .../zend-registry-usage-in-dotkernel.md       |  46 +--
 ...dotkernel-refactor-of-dot-session-class.md |  46 ++-
 ...tter-file-for-dotkernel-coding-standard.md |  13 +-
 .../development-report-december-11-2017.md    |  19 +-
 .../dotkernel3/dotkernel-admin-v4.md          |  75 ++---
 .../dotkernel-admin-version-3-launched.md     |  36 +--
 ...tkernel-api-architecture-and-components.md | 157 ++++------
 .../dotkernel-frontend-version-3-launched.md  |  31 +-
 .../dotkernel3-stable-release-version-1-0.md  |  29 +-
 .../php-8-3-support-in-dotkernel-admin.md     | 116 +++----
 .../php-8-3-support-in-dotkernel-api.md       | 129 ++++----
 .../php-8-3-support-in-dotkernel-frontend.md  |  73 ++---
 ...ry-admin-in-dotkernel-headless-platform.md |  84 +++---
 ...the-root-of-dotkernel-headless-platform.md |  67 +++--
 ...adless-platform-the-whats-hows-and-whys.md | 116 +++----
 ...xecution-in-dotkernel-headless-platform.md | 129 ++++----
 ...maker-generate-common-code-in-dotkernel.md | 102 ++++---
 ...evolution-pattern-versus-api-versioning.md | 103 ++++---
 ...sed-one-time-password-totp-in-dotkernel.md | 146 +++++----
 ...ubmodule-in-dotkernel-headless-platform.md |  75 ++---
 ...adds-postgresql-native-uuid-and-php-8-5.md |  19 +-
 ...cy-setup-in-dotkernel-using-mezzio-cors.md |  63 ++--
 ...reating-admin-accounts-in-dotkernel-api.md | 117 +++-----
 ...database-migrations-and-how-to-use-them.md |  89 +++---
 .../doctrine-cache-in-mezzio-and-dotkernel.md |  86 +++---
 ...igration-without-dropping-custom-tables.md |  51 ++--
 ...ly-url-in-an-generic-laminas-mezzio-app.md |  47 ++-
 ...in-wsl2-php-mariadb-composer-phpmyadmin.md |  57 ++--
 ...ndpoints-in-dotkernel-api-using-dot-cli.md |  35 ++-
 ...-zend-expressive-2-to-zend-expressive-3.md |  88 ++----
 ...nsole-with-dot-cli-based-on-laminas-cli.md |  69 +++--
 ...an-for-documentation-in-dotkernel-api-3.md | 142 +++++----
 ...sing-the-urlgenerator-work-in-fastroute.md |  49 ++-
 .../what-is-cross-origin-token-redemption.md  |  31 +-
 .../how-to/what-is-psr-7-and-how-to-use-it.md | 113 ++++---
 ...free-php-html-css-javascript-editor-ide.md |  50 ++--
 .../md-articles/javascript/intro-to-jquery.md |  41 +--
 .../javascript/javascript-email-validator.md  |  10 +-
 ...-versus-lgpl-in-practice-dotkernel-case.md |  45 ++-
 ...provements-psr-15-handlers-vite-phpstan.md |  51 ++--
 ...ic-routing-using-fastroute-in-dotkernel.md |  52 ++--
 ...5-compliant-handlers-in-dotkernel-light.md |  86 +++---
 ...-php-apache-mariadb-composer-phpmyadmin.md |  34 ++-
 .../aptana-php-installation-in-aptana-2-x.md  |   5 +-
 ...er-unicode-support-in-mysql-5-5-utf8mb4.md |  23 +-
 ...seeding-doctrine-data-fixtures-vs-phinx.md |  99 +++---
 .../end-of-support-for-php-5-2-x-branch.md    |  20 +-
 ...oint-arithmetic-why-is-int-0-7-0-1-10-7.md |  98 +++---
 .../how-to-upgrade-wamp-to-php-5-3-4.md       |  77 ++---
 .../mezzio-app-development-in-wsl2.md         |  56 ++--
 ...ased-no-upgrade-possible-for-wampserver.md |  16 +-
 ...ironment-development-staging-production.md |  28 +-
 .../php-support-back-in-aptana-3-0.md         |  33 +-
 ...ion-using-pdo-and-zend-framework-part-2.md |  53 ++--
 ...-injection-using-pdo-and-zend-framework.md |  62 +++-
 ...-to-mysql-server-on-plesk-based-servers.md |  27 +-
 ...c-analysis-replacing-psalm-with-phpstan.md |  35 ++-
 ...-to-connect-to-dotkernel-tracker-mantis.md |  66 ++--
 .../using-php-7-express-in-zend-studio-13.md  |  64 ++--
 ...-control-ignore-patterns-in-zend-studio.md |  18 +-
 ...end-certified-engineer-in-dotboost-team.md |  13 +-
 .../zend-server-5-5-quick-setup-on-windows.md |  47 ++-
 ...x-installing-pear-packages-with-php-7-2.md |  51 ++--
 ...s-the-intl-php-extension-problem-solved.md |  90 +++---
 ...-quality-how-to-setup-phpcs-in-phpstorm.md |  68 ++---
 ...debug-bar-a-very-helpfull-zf-debug-tool.md |   8 +-
 ...tting-pear-channel-for-zend-framework-1.md |  11 +-
 .../wurfl-php-api-libraries-gpl-versions.md   |   7 +-
 ...ork-1-12-4-released-with-security-fixes.md |   9 +-
 .../zend-framework-1-7-0-released.md          |   9 +-
 .../zend-framework-1-end-of-life.md           |  23 +-
 ...r-accessible-repository-on-plesk-server.md |  47 ++-
 ...ecurity-fixes-in-zend-framework-1-12-12.md |  35 ++-
 164 files changed, 4486 insertions(+), 4313 deletions(-)

diff --git a/public/md-articles/android/listen-for-android-install-referrer.md b/public/md-articles/android/listen-for-android-install-referrer.md
index 6aa70150..1f72e30d 100644
--- a/public/md-articles/android/listen-for-android-install-referrer.md
+++ b/public/md-articles/android/listen-for-android-install-referrer.md
@@ -12,14 +12,15 @@ language: "en"
 
 ## Getting Referrer Data at Install Time
 
-Have you ever wondered if Android market sends you information at the moment of app install? Wouldn't it be nice to create custom links to your Android application, including bits of information about the referrer, and send it directly to the app for processing at install? This could be a simple and accurate solution for mobile app install tracking, but I'm sure you can find this useful in many ways.
-
-With Android, you actually get this information as a broadcasted intent by Android market at install time - even before opening your app...
+Android market sends information at the moment of app install, delivered as a broadcasted intent by Android market at install time - even before the app is opened for the first time.
+This can be used to create custom links to an Android application, including bits of information about the referrer, sent directly to the app for processing at install.
+It can be a simple and accurate solution for mobile app install tracking, among other uses.
 
 ## FAQ
 
 **Q: Does Android send information when the app is installed?**
-A: Yes. Android market broadcasts an intent containing referrer information at the moment the app is installed.
+A: Yes.
+Android market broadcasts an intent containing referrer information at the moment the app is installed.
 
 **Q: When is this referrer information available to the app?**
 A: It's delivered as a broadcasted intent at install time, before the app is ever opened.
diff --git a/public/md-articles/android/multiple-broadcast-receivers-in-the-same-app-for-the-same-action.md b/public/md-articles/android/multiple-broadcast-receivers-in-the-same-app-for-the-same-action.md
index 7afd272e..692bc596 100644
--- a/public/md-articles/android/multiple-broadcast-receivers-in-the-same-app-for-the-same-action.md
+++ b/public/md-articles/android/multiple-broadcast-receivers-in-the-same-app-for-the-same-action.md
@@ -10,9 +10,14 @@ language: "en"
 
 # Multiple broadcast receivers in the same app, for the same action
 
-Did you come to a point where using multiple broadcast receivers to listen for the same intent, separatly, in the same android app, leads to unexpected results? If that's the case, one broadcast receiver might consume the broadcasted intent, [online casino](http://www.cillap.com/) leaving the others with nothing to receive. This can be the case where you use 3rd party libraries with broadcast receivers defined.
+## The problem
 
-The following is a solution for this kind of problem, a code snippet inspired by the way Admob for android seems to solve this, as shown in their [documentation](http://developer.admob.com/wiki/Android_App_Download_Tracking), using meta-data in manifest file...[[read more](http://n3vrax.wordpress.com/2011/07/15/multiple-broadcast-receivers-in-the-same-app-for-the-same-action/)].
+When multiple broadcast receivers are registered separately to listen for the same intent within the same Android app, this can lead to unexpected results: one broadcast receiver might consume the broadcasted intent, leaving the others with nothing to receive.
+This can happen when using 3rd party libraries that define their own broadcast receivers alongside an app's own receivers.
+
+## The approach
+
+A solution for this kind of problem is a code snippet inspired by the way Admob for Android solves this, as shown in Admob's own documentation, using meta-data in the manifest file.
 
 ## FAQ
 
@@ -21,3 +26,7 @@ A: When multiple broadcast receivers are registered separately to listen for the
 
 **Q: When is this issue most likely to occur?**
 A: This can happen when you use 3rd party libraries that already define their own broadcast receivers alongside your app's own receivers.
+
+## Resources
+
+- [Admob App Download Tracking documentation](http://developer.admob.com/wiki/Android_App_Download_Tracking)
diff --git a/public/md-articles/architecture/configprovider-bootstrap-modern-php-applications.md b/public/md-articles/architecture/configprovider-bootstrap-modern-php-applications.md
index ecebcc44..992aca41 100644
--- a/public/md-articles/architecture/configprovider-bootstrap-modern-php-applications.md
+++ b/public/md-articles/architecture/configprovider-bootstrap-modern-php-applications.md
@@ -11,27 +11,25 @@ language: "en"
 # ConfigProvider - Bootstrap Modern PHP Applications
 
 ## TL;DR
+
 In PHP, a `ConfigProvider` is a class or callable that is part of an application's bootstrap process, returning configuration data that tells the platform which middleware should run, in what order, and under what conditions.
 Frameworks like Mezzio, Laminas, Slim, and the Dotkernel Headless Platform use ConfigProviders to declare middleware pipeline configuration, dependency injection mappings, and request handlers, which get merged together automatically during bootstrap (except in Dotkernel, where new ConfigProviders must be registered manually).
 
-In PHP, the `ConfigProvider` is a class that is part of an application's bootstrap process. **It's a class or callable that returns configuration data telling the platform which middleware should run, in what order, and sometimes under what conditions.**
-
-If you're talking specifically about the ConfigProvider in the Laminas/Mezzio ecosystem, it's literally an array of configuration, settings, or anything else your application needs.
-
 ## Where Is the ConfigProvider Used?
 
-Mezzio (formerly Zend Expressive), Laminas, Slim, the Dotkernel Headless Platform, or other middleware-based frameworks often have a `ConfigProvider` class. In Laminas/Mezzio specifically, each module or package may contain a `ConfigProvider` that returns:
+Mezzio (formerly Zend Expressive), Laminas, Slim, the Dotkernel Headless Platform, and other middleware-based frameworks often have a `ConfigProvider` class.
+In Laminas/Mezzio specifically, each module or package may contain a `ConfigProvider` that returns:
 
-- Middleware pipeline configuration.
+- Middleware pipeline configuration:
   - Middleware classes or service names.
   - Error-handling middleware, which should have the lowest priority.
   - Middleware groups or nested arrays.
 - Dependency injection mappings.
 - Request Handlers.
 
-Example in Dotkernel, which is an approach similar to Laminas/Mezzio:
+Example structure used in Dotkernel:
 
-```
+```php
 class ConfigProvider
 {
     public function __invoke(): array
@@ -44,46 +42,42 @@ class ConfigProvider
 
     public function getDependencies(): array
     {
-        return ,
-           'invokables'   => ,
+        return [
+            'factories'  => [ /* ... */ ],
+            'invokables' => [ /* ... */ ],
         ];
     }
 
     public function getTemplates(): array
     {
-        return ,
-        'error'  => ,
+        return [
+            'paths' => [ /* ... */ ],
+            'error' => [ /* ... */ ],
         ];
     }
 }
 ```
 
-What each item above means:
+What each item means:
 
-- `dependencies` is used by the dependency injector (like [laminas-servicemanager](https://docs.mezzio.dev/mezzio/v3/features/container/laminas-servicemanager/)) to construct every requested service.
-  - `factories` will have the factory build the service.
-  - `invokables` will use `new` directly.
-  - You can also use `aliases` to redirect to another service name and `delegators` to wrap the original service.
-- `templates` defines the paths for the template files.
+| Item | Meaning |
+|---|---|
+| `dependencies` | Used by the dependency injector (e.g. [laminas-servicemanager](https://docs.mezzio.dev/mezzio/v3/features/container/laminas-servicemanager/)) to construct every requested service. |
+| `factories` | The factory builds the service. |
+| `invokables` | The service is built with `new` directly. |
+| `aliases` | Redirects to another service name. |
+| `delegators` | Wraps the original service. |
+| `templates` | Defines the paths for the template files. |
 
-## How the ConfigProvider works
+## How the ConfigProvider Works
 
-The ConfigProvider is automatically picked up by the framework during application bootstrap. Let's look at it step by step:
+The ConfigProvider is automatically picked up by the framework during application bootstrap:
 
-- **Merge the global configuration** - All ConfigProviders are merged into one array.
-- **Read the configuration array** - The call is similar to the below and expects an array of entries:
-
-```
-$config = $container->get('config') ?? [];
-```
-
-- **Resolve item** - `$app->pipe()` is called to resolve one of the below instances:
-  - Resolve the service name from the container
-  - Wrap the middleware, if an array is provided
-  - Call the closure or invokable object.
-- **Handle errors** - This middleware is the last one in the pipeline to make sure it handles any exceptions.
-- **Execute at runtime** - [Laminas Stratigility](https://docs.laminas.dev/laminas-stratigility/) iterates over the pipeline in the order it was registered.
-  - Each middleware can **handle** the request and return a response, or **delegate** execution to the next middleware in the pipeline, until a `ResponseInterface` is returned to the client.
+1. **Merge the global configuration** - All ConfigProviders are merged into one array.
+2. **Read the configuration array** - A call similar to `$config = $container->get('config') ?? [];` reads an array of entries.
+3. **Resolve item** - `$app->pipe()` is called to resolve one of the following: resolve the service name from the container, wrap the middleware if an array is provided, or call the closure or invokable object.
+4. **Handle errors** - The error-handling middleware is the last one in the pipeline, to make sure it can handle any exceptions.
+5. **Execute at runtime** - [Laminas Stratigility](https://docs.laminas.dev/laminas-stratigility/) iterates over the pipeline in the order it was registered. Each middleware can handle the request and return a response, or delegate execution to the next middleware in the pipeline, until a `ResponseInterface` is returned to the client.
 
 Below you can see how Mezzio and Dotkernel merge and use ConfigProviders to build the middleware pipeline and dependencies.
 
@@ -91,22 +85,14 @@ Below you can see how Mezzio and Dotkernel merge and use ConfigProviders to buil
 
 ## Benefits
 
-- Centralized setup – Instead of hardcoding bootstrap code, you declare it in a config provider so it's easy to read, change, or extend.
-- Modular – Each package can ship with its own config without interfering with others.
-- Container-friendly – It works well with frameworks using DI containers like Laminas ServiceManager, PHP-DI, or Pimple.
-- Standardized service definitions - It has consistent rules for object creation that are separate from business logic.
-- Auto-Discovery - In Laminas/Mezzio, the [ConfigAggregator](https://docs.laminas.dev/laminas-config-aggregator/) automatically loads and merges all ConfigProviders.
-
-> Dotkernel is an exception to this rule: new ConfigProviders have to be added manually in `config/config.php`, because all the initial ConfigProviders required to install the applications are already injected.
-
-- Environment-agnostic - It returns an array that defines dev, test, or prod environments.
-- Testability - The consistent, central configuration promotes isolated (e.g. per-module) testing, easier swapping of dependencies and the assertion of pipeline setup (e.g. check if a config key is present).
-
-## Additional Resources
-
-- [Mezzio Container](https://docs.mezzio.dev/mezzio/v3/features/container/config/)
-- [Laminas Config Aggregator](https://docs.laminas.dev/laminas-config-aggregator/config-providers/)
-- [PSR-15 (HTTP Server Request Handlers)](https://www.php-fig.org/psr/psr-15/)
+- **Centralized setup** - Instead of hardcoding bootstrap code, it's declared in a config provider so it's easy to read, change, or extend.
+- **Modular** - Each package can ship with its own config without interfering with others.
+- **Container-friendly** - Works well with frameworks using DI containers like Laminas ServiceManager, PHP-DI, or Pimple.
+- **Standardized service definitions** - Consistent rules for object creation, separate from business logic.
+- **Auto-Discovery** - In Laminas/Mezzio, the [ConfigAggregator](https://docs.laminas.dev/laminas-config-aggregator/) automatically loads and merges all ConfigProviders.
+Dotkernel is an exception: new ConfigProviders have to be added manually in `config/config.php`, because all the initial ConfigProviders required to install the applications are already injected.
+- **Environment-agnostic** - Returns an array that defines dev, test, or prod environments.
+- **Testability** - The consistent, central configuration promotes isolated (e.g. per-module) testing, easier swapping of dependencies, and assertion of pipeline setup (e.g. checking if a config key is present).
 
 ## FAQ
 
@@ -117,13 +103,20 @@ A: It is a class that is part of an application's bootstrap process: a class or
 A: In the Laminas/Mezzio ecosystem, it's literally an array of configuration, settings, or anything else the application needs, and each module or package may contain its own ConfigProvider returning middleware pipeline configuration, dependency injection mappings, and request handlers.
 
 **Q: What is the difference between 'factories' and 'invokables' in the dependencies array?**
-A: factories will have the factory build the service, while invokables will use new directly. You can also use aliases to redirect to another service name and delegators to wrap the original service.
+A: `factories` will have the factory build the service, while `invokables` will use `new` directly.
+You can also use `aliases` to redirect to another service name and `delegators` to wrap the original service.
 
 **Q: How does the ConfigProvider get used during application bootstrap?**
-A: It is automatically picked up by the framework during bootstrap: all ConfigProviders are merged into one array, the configuration array is read (similar to $config = $container->get('config') ?? [];), each item is resolved via $app->pipe(), the error-handling middleware is placed last in the pipeline, and at runtime Laminas Stratigility iterates over the pipeline in the order it was registered.
+A: It is automatically picked up by the framework during bootstrap: all ConfigProviders are merged into one array, the configuration array is read, each item is resolved via `$app->pipe()`, the error-handling middleware is placed last in the pipeline, and at runtime Laminas Stratigility iterates over the pipeline in the order it was registered.
 
 **Q: Are new ConfigProviders auto-discovered in Dotkernel?**
-A: Dotkernel is an exception to the usual auto-discovery rule: new ConfigProviders have to be added manually in config/config.php, because all the initial ConfigProviders required to install the applications are already injected.
+A: Dotkernel is an exception to the usual auto-discovery rule: new ConfigProviders have to be added manually in `config/config.php`, because all the initial ConfigProviders required to install the applications are already injected.
 
 **Q: What are the benefits of using a ConfigProvider?**
 A: Benefits include centralized setup instead of hardcoded bootstrap code, modularity so each package can ship its own config, container-friendliness with DI containers like Laminas ServiceManager, PHP-DI or Pimple, standardized service definitions, environment-agnostic configuration for dev/test/prod, and better testability of the pipeline setup.
+
+## Resources
+
+- [Mezzio Container](https://docs.mezzio.dev/mezzio/v3/features/container/config/)
+- [Laminas Config Aggregator](https://docs.laminas.dev/laminas-config-aggregator/config-providers/)
+- [PSR-15 (HTTP Server Request Handlers)](https://www.php-fig.org/psr/psr-15/)
diff --git a/public/md-articles/architecture/request-lifecycle-for-a-mezzio-based-application.md b/public/md-articles/architecture/request-lifecycle-for-a-mezzio-based-application.md
index 889caffe..092d85f8 100644
--- a/public/md-articles/architecture/request-lifecycle-for-a-mezzio-based-application.md
+++ b/public/md-articles/architecture/request-lifecycle-for-a-mezzio-based-application.md
@@ -11,59 +11,45 @@ language: "en"
 # Request Lifecycle for a Mezzio-Based Application
 
 ## TL;DR
-The request lifecycle is the sequence of steps that happen from the moment a user makes an HTTP request until the server sends back a response.
-This is illustrated using Dotkernel Light, one of the applications in the Dotkernel Headless Platform suite, walking through entry point setup, routing, handler execution, template rendering, response creation, and the response emitter.
-
-## Seamlessly Interconnected Middleware for Enterprise-Level Solutions
 
 The request lifecycle is the sequence of steps that happen from the moment a user makes an HTTP request until the server sends back a response.
+This is illustrated using Dotkernel Light, one of the applications in the Dotkernel Headless Platform suite, walking through entry point setup, routing, handler execution, template rendering, response creation, and the response emitter.
 
-The graph below shows how the request is handled by **Dotkernel Light** ([GitHub](https://github.com/dotkernel/light), [documentation](https://docs.dotkernel.org/light-documentation/)), one of the applications in the [Dotkernel Headless Platform suite](https://github.com/dotkernel).
-
-> Hover over items for description
-
-Entry Point
-
-1. HTTP Request
-[public/index.php]
-
-2. Service Container
-
-3. Route Registration
-
-4. Middleware Pipeline
-[config/pipeline.php]
-
-5. Routing
-
-6. Handler
-Invocation
-
-7. Custom Logic
-Execution in Handler
-
-8. Template
-Rendering [twig]
-
-9. Response
-Creation
-
-10. Response
-Pipeline
-
-asd
-
-asd
-
-asd
-
-11. Response Emitter
-
-HTTP 20x, 30x
-
-HTTP 40x
-
-HTTP 50x
+## The Request Lifecycle, Step by Step
+
+### Entry Point
+
+1. **HTTP Request** - Bootstrap the application, load configuration and create the Mezzio application instance.
+2. **Service Container** - Register factories, aliases and delegators.
+All services are configured and ready to use.
+3. **Route Registration** - Read all available routes with their allowed request methods and dynamically register them in the application.
+Routes are managed by FastRoute.
+Example: `/page/about` -> `GetPageViewHandler`, Method: `GET`, Route name: `page::about`.
+4. **Middleware Pipeline** - Loads the predefined order of middleware.
+It defines how incoming HTTP requests move through the application and how responses are generated.
+
+### Processing
+
+5. **Routing** - FastRoute matches the URL and method against registered routes.
+Match: `GET /page/about`, Handler: `GetPageViewHandler`, Route name: `page::about`.
+6. **Handler Invocation** - Extract the matched route name from the request and pass it to the renderer:
+   ```php
+   $template = $request->getAttribute(RouteResult::class)->getMatchedRouteName();
+   // $template = 'page::about';
+   ```
+7. **Custom Logic Execution in Handler** - Execute the business logic in the handler.
+The process can involve services and any custom logic.
+8. **Template Rendering** - Twig loads the template, applies the layout, renders blocks and includes partials.
+Load: `src/Page/templates/page/about.html.twig`, Extends: `@layout/default.html.twig`, Render blocks: `title`, `content`, Include partials: `alerts.html.twig`, etc., Output: Final HTML.
+9. **Response Creation** - An `HtmlResponse` is created with status, headers and the rendered HTML body.
+Status: `200 OK`, Content-Type: `text/html; charset=utf-8`, Body: Rendered HTML.
+10. **Response Pipeline** - The response flows back through the middleware stack.
+Middleware can modify headers, cookies, compress content, etc.
+
+### Exit Point
+
+11. **Response Emitter** - The final response is sent back to the browser.
+The page is rendered and sent to the user, as one of `HTTP 20x/30x`, `HTTP 40x`, or `HTTP 50x`.
 
 ## FAQ
 
@@ -74,13 +60,20 @@ A: The request lifecycle is the sequence of steps that happen from the moment a
 A: The application bootstraps and loads configuration to create the Mezzio application instance, registers factories, aliases and delegators in the service container, reads all available routes with their allowed request methods and registers them (managed by FastRoute), and loads the predefined order of middleware in the pipeline.
 
 **Q: How does routing work in a Mezzio-based application?**
-A: FastRoute matches the incoming URL and method against the registered routes, for example matching a GET request to /page/about against the GetPageViewHandler handler under the route name page::about.
+A: FastRoute matches the incoming URL and method against the registered routes, for example matching a GET request to `/page/about` against the `GetPageViewHandler` handler under the route name `page::about`.
 
 **Q: What happens during handler invocation?**
-A: The matched route name is extracted from the request attribute and passed to the renderer, using code similar to $template = $request->getAttribute(RouteResult::class)->getMatchedRouteName();, after which the handler executes the custom business logic.
+A: The matched route name is extracted from the request attribute and passed to the renderer, using code similar to `$template = $request->getAttribute(RouteResult::class)->getMatchedRouteName();`, after which the handler executes the custom business logic.
 
 **Q: What happens during template rendering?**
 A: Twig loads the matched template file, applies the layout it extends, renders its blocks, and includes any partials, producing the final HTML output.
 
 **Q: How is the response created and returned to the browser?**
-A: An HtmlResponse is created with a status code, headers, and the rendered HTML body. It then flows back through the middleware stack in reverse (the response pipeline), where middleware can modify headers, cookies, or compress content, before the response emitter sends the final response back to the browser as HTTP 20x/30x, 40x, or 50x.
+A: An `HtmlResponse` is created with a status code, headers, and the rendered HTML body.
+It then flows back through the middleware stack in reverse (the response pipeline), where middleware can modify headers, cookies, or compress content, before the response emitter sends the final response back to the browser as HTTP 20x/30x, 40x, or 50x.
+
+## Resources
+
+- [Dotkernel Light on GitHub](https://github.com/dotkernel/light)
+- [Dotkernel Light documentation](https://docs.dotkernel.org/light-documentation/)
+- [Dotkernel Headless Platform suite on GitHub](https://github.com/dotkernel)
diff --git a/public/md-articles/architecture/understanding-middleware.md b/public/md-articles/architecture/understanding-middleware.md
index 1fd2a8d1..d2ccde1e 100644
--- a/public/md-articles/architecture/understanding-middleware.md
+++ b/public/md-articles/architecture/understanding-middleware.md
@@ -11,18 +11,18 @@ language: "en"
 # Understanding Middleware
 
 ## TL;DR
+
 Middleware is code that exists between the request and response: it can take an incoming request, act on it, and either complete the response itself or delegate to the next middleware in the queue.
 It's used for concerns like authentication, CORS, caching, rate limiting, and more, and in PHP a PSR-15 compliant middleware implements `Psr\Http\Server\MiddlewareInterface` with a single `process()` method.
 
-**Middleware** is code that exists **between the request and response**, and which can take the incoming request, perform actions based on it, and either **complete the response or pass delegation** on to the next middleware in the queue.
-
-## The purpose of middleware
+## The Purpose of Middleware
 
-Middleware makes it easier for software developers to implement communication and input/output, so they can focus on the specific purpose of their application. In web services the `Input` represents the `Request` received, and `Output` represents the `Response` to be sent.
+Middleware makes it easier for software developers to implement communication and input/output, so they can focus on the specific purpose of their application.
+In web services, the `Input` represents the `Request` received, and `Output` represents the `Response` to be sent.
 
-## Using middleware
+## Using Middleware
 
-Middleware can be used to, but is not limited to, the following purposes:
+Middleware can be used for purposes such as, but not limited to:
 
 - A/B Testing
 - Debugging
@@ -36,21 +36,22 @@ Middleware can be used to, but is not limited to, the following purposes:
 
 ## Usage
 
-According to [PSR-15: HTTP Server Request Handlers](https://www.php-fig.org/psr/psr-15/), a component that processes an incoming request and generates a response is a middleware. To be compliant with the PSR-15 standard, the middleware must implement [Psr\Http\Server\MiddlewareInterface](https://github.com/php-fig/http-server-middleware).
+According to PSR-15: HTTP Server Request Handlers, a component that processes an incoming request and generates a response is a middleware.
+To be compliant with the PSR-15 standard, the middleware must implement `Psr\Http\Server\MiddlewareInterface`:
 
-```
+```php
 class MyMiddleware implements MiddlewareInterface
 ```
 
-The middleware class must then implement the `process` method.
+The middleware class must then implement the `process` method:
 
-```
+```php
 public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface;
 ```
 
-Below is an example implementation of a middleware which processes the request.
+Example implementation of a middleware which processes the request:
 
-```
+```php
 class ExampleMiddleware implements MiddlewareInterface
 {
     public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
@@ -62,9 +63,9 @@ class ExampleMiddleware implements MiddlewareInterface
 }
 ```
 
-This is an example implementation of a middleware which processes the response.
+Example implementation of a middleware which processes the response:
 
-```
+```php
 class ExampleMiddleware implements MiddlewareInterface
 {
     public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
@@ -78,9 +79,9 @@ class ExampleMiddleware implements MiddlewareInterface
 }
 ```
 
-This approach processes both the request and response.
+An approach that processes both the request and response:
 
-```
+```php
 class ExampleMiddleware implements MiddlewareInterface
 {
     public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
@@ -96,29 +97,24 @@ class ExampleMiddleware implements MiddlewareInterface
 }
 ```
 
-## How middleware is called
+## How Middleware Is Called
 
-The **application pipeline** defines the execution flow. The request passes through the middleware in the pipeline, one by one, in the order they are placed in the pipeline. Each middleware processes the request and/or response and either **passes control** to the next middleware in the chain or it **terminates the request** and returns a reponse.
+The application pipeline defines the execution flow.
+The request passes through the middleware in the pipeline, one by one, in the order they are placed in the pipeline.
+Each middleware processes the request and/or response and either passes control to the next middleware in the chain or terminates the request and returns a response.
 
-- If control passes through all middleware successfully, the execution is eventually passed to your custom code which generates a response of its own. The execution then passes through the middleware in reverse order and returns the response.
-- If the execution is terminated before reaching your custom code (e.g. via an exception), then the response is generated by the last middleware reached by the execution.
+- If control passes through all middleware successfully, execution is eventually passed to the custom code which generates a response of its own.
+Execution then passes through the middleware in reverse order and returns the response.
+- If execution is terminated before reaching the custom code (e.g. via an exception), the response is generated by the last middleware reached by the execution.
 
-## Middleware in practice
+## Middleware in Practice
 
-A simple real world example of middleware usage can be the enhancement of a request with the user IP for logging porposes or building reports based on geographical data. For this example the pipeline has a single middleware.
+A simple real world example of middleware usage is the enhancement of a request with the user IP for logging purposes or building reports based on geographical data.
+For this example the pipeline has a single middleware.
 
-The flow begins with a request. The execution passes the control to the IP middleware which enhances the request with the user's IP and other relevant data. The control passes to your custom handler that processes the request and returns a response. The flow continues in reverse order, back to the IP middleware which can, if needed, change the output before it gets returned to the user that initiated the request.
-
-## Additional resources:
-
-- [Why Care About PHP Middleware?](https://philsturgeon.uk/php/2016/05/31/why-care-about-php-middleware/)
-- [Learn more about Mezzio from the source](https://docs.mezzio.dev/)
-- [Laminas components](https://docs.laminas.dev/components/)
-- [Dotkernel Light, the smallest complete Mezzio application](https://github.com/dotkernel/light)
-- [The Slim PHP micro framework](https://www.slimframework.com/)
-- [The PHP Framework Interop Group's full list of PSRs](https://www.php-fig.org/psr/)
-- [PSR-7: The magical middleware tour](https://vimeo.com/showcase/4061778/video/177154167)
-- [From Helpers to Middleware](https://www.youtube.com/watch?v=v1I57-_Rsv0)
+The flow begins with a request. Execution passes control to the IP middleware, which enhances the request with the user's IP and other relevant data.
+Control passes to the custom handler that processes the request and returns a response.
+The flow continues in reverse order, back to the IP middleware, which can, if needed, change the output before it gets returned to the user that initiated the request.
 
 ## FAQ
 
@@ -126,16 +122,31 @@ The flow begins with a request. The execution passes the control to the IP middl
 A: Middleware is code that exists between the request and response, and which can take the incoming request, perform actions based on it, and either complete the response or pass delegation on to the next middleware in the queue.
 
 **Q: What is the purpose of middleware?**
-A: Middleware makes it easier for software developers to implement communication and input/output, so they can focus on the specific purpose of their application. In web services, the Input represents the Request received, and Output represents the Response to be sent.
+A: Middleware makes it easier for software developers to implement communication and input/output, so they can focus on the specific purpose of their application.
+In web services, the Input represents the Request received, and Output represents the Response to be sent.
 
 **Q: What can middleware be used for?**
 A: Middleware can be used for purposes such as A/B testing, debugging, caching, CORS, authentication (HTTP Basic Auth, OAuth 2.0, OpenID), CSRF protection, rate limiting, referrals, and IP restriction.
 
 **Q: What interface must PHP middleware implement to be PSR-15 compliant?**
-A: According to PSR-15, a compliant middleware must implement Psr\Http\Server\MiddlewareInterface, which requires a process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface method.
+A: According to PSR-15, a compliant middleware must implement `Psr\Http\Server\MiddlewareInterface`, which requires a `process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface` method.
 
 **Q: How does middleware get called within the application pipeline?**
-A: The application pipeline defines the execution flow: the request passes through the middleware one by one, in the order they are placed. If control passes through all middleware successfully, execution is passed to your custom code, which generates a response, and execution then passes back through the middleware in reverse order. If execution is terminated before reaching your custom code (e.g. via an exception), the response is generated by the last middleware reached.
+A: The application pipeline defines the execution flow: the request passes through the middleware one by one, in the order they are placed. If control passes through all middleware successfully, execution is passed to your custom code, which generates a response, and execution then passes back through the middleware in reverse order.
+If execution is terminated before reaching your custom code (e.g. via an exception), the response is generated by the last middleware reached.
 
 **Q: What is a practical, real-world example of middleware?**
-A: A simple example is enhancing a request with the user's IP for logging purposes or geographical reporting. The request first passes through the IP middleware, which enhances the request with the user's IP and other relevant data, then control passes to the custom handler that processes the request and returns a response. The flow continues in reverse, back through the IP middleware, which can change the output before it's returned to the user.
+A: A simple example is enhancing a request with the user's IP for logging purposes or geographical reporting.
+The request first passes through the IP middleware, which enhances the request with the user's IP and other relevant data, then control passes to the custom handler that processes the request and returns a response.
+The flow continues in reverse, back through the IP middleware, which can change the output before it's returned to the user.
+
+## Resources
+
+- [Why Care About PHP Middleware?](https://philsturgeon.uk/php/2016/05/31/why-care-about-php-middleware/)
+- [Learn more about Mezzio from the source](https://docs.mezzio.dev/)
+- [Laminas components](https://docs.laminas.dev/components/)
+- [Dotkernel Light, an implementation of Mezzio using handlers](https://github.com/dotkernel/light)
+- [The Slim PHP micro framework](https://www.slimframework.com/)
+- [The PHP Framework Interop Group's full list of PSRs](https://www.php-fig.org/psr/)
+- [PSR-7: The magical middleware tour](https://vimeo.com/showcase/4061778/video/177154167)
+- [From Helpers to Middleware](https://www.youtube.com/watch?v=v1I57-_Rsv0)
diff --git a/public/md-articles/best-practice/aptana-set-svn-keywords.md b/public/md-articles/best-practice/aptana-set-svn-keywords.md
index 34501c99..f9e55a12 100644
--- a/public/md-articles/best-practice/aptana-set-svn-keywords.md
+++ b/public/md-articles/best-practice/aptana-set-svn-keywords.md
@@ -14,15 +14,15 @@ In Aptana it's very simple to set the [svn:keywords](http://svnbook.red-bean.com
 
 For example if you want to set the svn keyword property ***Id***:
 
-- In the file where you want to add the svn keyword property write **$Id$**
+1. In the file where you want to add the svn keyword property write **$Id$**
 
 ![](/uploads/article/019f8a80-cc86-73d9-a427-0621b2a55777/id-file-300x235.gif)
 
-- Right click on the file, then follow Team -> Set Property...**Note***: *Set Property...* will not be active if you haven't first added the file to SVN: *Team*->*Add to Version Controller*
+2. Right click on the file, then follow Team -> Set Property...**Note**: *Set Property...* will not be active if you haven't first added the file to SVN: *Team*->*Add to Version Controller*
 
 ![](/uploads/article/019f8a80-cc86-73d9-a427-0621b2a55777/set-property-300x152.gif)
 
-- Select **svn:keywords**, and write **Id** in the text field 
+3. Select **svn:keywords**, and write **Id** in the text field
 
 ![](/uploads/article/019f8a80-cc86-73d9-a427-0621b2a55777/svn-keywords-300x298.gif)
 
@@ -36,7 +36,12 @@ When you make the SVN commit of the file, the *$Id$* keyword will be replaced wi
 A: Write the keyword marker (for example $Id$) in the file, then right click the file and follow Team -> Set Property..., select svn:keywords, and write Id in the text field.
 
 **Q: Why is "Set Property..." not active when I right click the file?**
-A: Set Property... will not be active if the file hasn't first been added to SVN. Use Team -> Add to Version Controller before trying to set the property.
+A: Set Property... will not be active if the file hasn't first been added to SVN.
+Use Team -> Add to Version Controller before trying to set the property.
 
 **Q: What happens to the $Id$ keyword after an SVN commit?**
 A: After the SVN commit of the file, the $Id$ keyword is replaced with text containing the file's SVN metadata, in a specific format.
+
+## Resources
+
+- [svn:keywords property documentation](http://svnbook.red-bean.com/en/1.4/svn.advanced.props.special.keywords.html)
diff --git a/public/md-articles/best-practice/basic-security-in-dotkernel-headless-platform.md b/public/md-articles/best-practice/basic-security-in-dotkernel-headless-platform.md
index 8dbb3310..a3ac45df 100644
--- a/public/md-articles/best-practice/basic-security-in-dotkernel-headless-platform.md
+++ b/public/md-articles/best-practice/basic-security-in-dotkernel-headless-platform.md
@@ -11,6 +11,7 @@ language: "en"
 # Basic Security in Dotkernel Headless Platform
 
 ## TL;DR
+
 Software security should always be top of mind for a developer, since ignoring it can lead to major costs, data loss, GDPR fines, or the loss of client trust. The article surveys many facets of software security and walks through the practical measures Dotkernel Headless Platform takes for each: input validation, content negotiation, CORS, RBAC, demo credentials, error reporting, OpenAPI docs, PHP and JavaScript dependencies, OAuth2, session/cookie settings, and CI checks.
 
 **Software security** should always be in the back of your mind as a developer. It may seem fine at first to deliver a feature sooner, only to find later on that you left a backdoor into your crisp new update. You ignore security at your own risk, with potentially major costs to your personal or your organization's image, and to your client's trust in your abilities. The costs to recover the damages caused by a lacking security are sometimes astronomical, enough to put a company out of business.
@@ -73,7 +74,7 @@ In Dotkernel API, CORS is handled by [mezzio/mezzio-cors](https://github.com/mez
 
 ## Role-Based Access Control
 
-Role-Based Access Control (or RBAC) is a security model used in software systems to manage access to resource. It does this by assigning roles to users types which are in turn assigned to users who require a certain level of access.
+Role-Based Access Control (or RBAC) is a security model used in software systems to manage access to resources. It does this by assigning roles to user types which are in turn assigned to users who require a certain level of access.
 
 Dotkernel API uses [mezzio/mezzio-authorization-rbac](https://github.com/mezzio/mezzio-authorization-rbac) for this purpose. There are several roles predefined, which you can configure to suit your project by editing the `config/autoload/authorization.global.php` file.
 
@@ -87,7 +88,7 @@ Demo credentials are provided in Dotkernel API for your convenience, to allow yo
 
 The purpose for the error reporting endpoint is to have a reliable channel through which 3rd-party developers can report issues to you directly.
 
-Dotkernel API has a dedicated endpoint `/error-report` for this purpose. It uses and `ErrorReportingToken` set up in the configuration file `config/autoload/error-handling.global.php`.
+Dotkernel API has a dedicated endpoint `/error-report` for this purpose. It uses an `ErrorReportingToken` set up in the configuration file `config/autoload/error-handling.global.php`.
 
 ## OpenAPI Documentation
 
@@ -99,7 +100,7 @@ OpenAPI documentation (formerly known as Swagger) provides a standardized, machi
 
 Dotkernel API implements [zircote/swagger-php](https://github.com/zircote/swagger-php) to provide an interactive documentation.
 
-> Do **not** include sensitive information for you endpoints. Do **not** enable documentation in a production environment.
+> Do **not** include sensitive information for your endpoints. Do **not** enable documentation in a production environment.
 
 ## PHP Dependencies
 
@@ -116,7 +117,7 @@ OAuth 2.0 is a secure authorization framework that allows one application to acc
 Dotkernel API uses the [mezzio/mezzio-authentication-oauth2](https://github.com/mezzio/mezzio-authentication-oauth2) for the OAuth2 authentication service. The package itself is secure, but you still need to make sure you use it properly:
 
 - Replace or update the default `admin` and `frontend` clients on your production environment.
-- Update the `access` and `refresh` tokens to match your aplication's requirements. The defaults are one day for `access` and one month for `refresh`.
+- Update the `access` and `refresh` tokens to match your application's requirements. The defaults are one day for `access` and one month for `refresh`.
 - Make sure to **not** commit any local keys generated by `./vendor/bin/generate-oauth2-keys`. They are used to verify the transmitted JWTs.
 
 ## Session and Cookie Settings
@@ -131,25 +132,26 @@ Dotkernel configures cookies in the `config/autoload/session.global.php` file. I
 
 ## JavaScript Dependencies
 
-Very much like `composer` for PHP, JavaScript has its own dependencies, usually installed via `npm` or `yarn`. The JavaScript ecosystem has recently been attacked by hackers who targetted several widely used npm packages that have a total number of uses in the billions.
+Very much like `composer` for PHP, JavaScript has its own dependencies, usually installed via `npm` or `yarn`. The JavaScript ecosystem has recently been attacked by hackers who targeted several widely used npm packages that have a total number of uses in the billions.
 
 Dotkernel uses `npm` to handle JavaScript dependencies. We monitor the news to stay on top of these security issues and use npm packages from reliable sources. Even so, you should regularly use the `npm audit` to check for vulnerabilities among your installed npm libraries.
 
 ## Other Security Considerations
 
-All components of **Dotkernel Headless Platform** have several configuration files with the name format `*.global.php', '*.php.dist` and `*.local.php`. You must **only** include sensitive information in the `*.local.php` files, since they are, by default, ignored by the VCS.
+All components of **Dotkernel Headless Platform** have several configuration files with the name format `*.global.php`, `*.php.dist` and `*.local.php`. You must **only** include sensitive information in the `*.local.php` files, since they are, by default, ignored by the VCS.
 
 The `development mode` is designed, as the name suggests, only for the development period. By enabling development mode, you enable features like debug mode, cache clear and show error details. These should be hidden from the production environment to avoid exposing sensitive data or code.
 
 The GitHub Action [Laminas Continuous Integration](https://github.com/laminas/laminas-continuous-integration-action) is an integral component of Dotkernel API. It ensures code quality by streamlining the execution of PHP quality assurance (QA) tasks within continuous integration (CI) workflows. Most often triggered by commits to the repository, it builds a matrix of tests: static analysis, coding standards checks, and unit tests.
 
-## Additional Resources
+## Resources
 
 - [Basic Security in Dotkernel Admin](https://docs.dotkernel.org/admin-documentation/v6/security/basic-security/)
 - [Basic Security in Dotkernel API](https://docs.dotkernel.org/api-documentation/v6/security/basic-security/)
 - [Content Negotiation in Dotkernel REST API](https://www.dotkernel.com/dotkernel-api/content-negotiation-in-dotkernel-rest-api/)
 - [laminas-form Documentation](https://docs.laminas.dev/laminas-form/v3/intro/)
 - [CORS in Dotkernel API](https://docs.dotkernel.org/api-documentation/v6/tutorials/cors/)
+- [CORS Policy Setup in Dotkernel](https://www.dotkernel.com/how-to/mezzio-cors-implementation-in-dotkernel/)
 - [Error Reporting Endpoint](https://docs.dotkernel.org/api-documentation/v6/core-features/error-reporting/)
 - [OpenAPI Documentation](https://docs.dotkernel.org/api-documentation/v6/openapi/introduction/)
 - [mezzio/mezzio-authentication-oauth2 Configuration](https://docs.mezzio.dev/mezzio-authentication-oauth2/v1/intro/#configuration)
@@ -160,13 +162,16 @@ The GitHub Action [Laminas Continuous Integration](https://github.com/laminas/la
 A: Software security spans many areas: authentication and access control, data protection, input validation and injection, web and API security, dependency and supply chain risks, configuration and deployment, network and infrastructure security, logging/monitoring and incident response, secure software development lifecycle, and human and organizational factors.
 
 **Q: How does Dotkernel handle form input validation?**
-A: Dotkernel API uses laminas/laminas-inputfilter to ensure a field is present and of the correct type. Dotkernel Admin additionally uses laminas/laminas-form, which provides form element objects, an InputFilter for each input (or custom validators), and methods for binding data to and from the form, integrating with laminas-escaper, laminas-validator, laminas-session, and laminas-filter.
+A: Dotkernel API uses laminas/laminas-inputfilter to ensure a field is present and of the correct type.
+Dotkernel Admin additionally uses laminas/laminas-form, which provides form element objects, an InputFilter for each input (or custom validators), and methods for binding data to and from the form, integrating with laminas-escaper, laminas-validator, laminas-session, and laminas-filter.
 
 **Q: How does Dotkernel API handle content negotiation?**
-A: Content negotiation is handled via a middleware configured in the config/autoload/content-negotiation.global.php file. It uses the Content-Type and Accept HTTP request headers to negotiate with the client, returning application/json or application/hal+json data formats.
+A: Content negotiation is handled via a middleware configured in the `config/autoload/content-negotiation.global.php` file.
+It uses the Content-Type and Accept HTTP request headers to negotiate with the client, returning application/json or application/hal+json data formats.
 
 **Q: How is CORS handled and configured in Dotkernel API?**
-A: CORS is handled by mezzio/mezzio-cors and configured in the config/autoload/cors.local.php file, validating calls using configuration items like origins, headers, max age, and credentials. When configuring the pipeline, the CorsMiddleware must be added before the RouteMiddleware.
+A: CORS is handled by mezzio/mezzio-cors and configured in the `config/autoload/cors.local.php` file, validating calls using configuration items like origins, headers, max age, and credentials.
+When configuring the pipeline, the CorsMiddleware must be added before the RouteMiddleware.
 
 **Q: What should be done with the demo credentials before going to production?**
 A: Demo credentials are provided for convenience during installation testing, but it is important to update or remove these accounts in your production environment.
diff --git a/public/md-articles/best-practice/golden-rules-of-professional-php-coding.md b/public/md-articles/best-practice/golden-rules-of-professional-php-coding.md
index b22c70e0..a371ec2e 100644
--- a/public/md-articles/best-practice/golden-rules-of-professional-php-coding.md
+++ b/public/md-articles/best-practice/golden-rules-of-professional-php-coding.md
@@ -12,26 +12,26 @@ language: "en"
 
 1.  Always use in development and in staging highest **error reporting** level, and **display_errors** ON:
 
-```
+```php
 error_reporting(-1);
 ini_set('display_errors', 1);
 ```
 
-2. **Fix** every warning or notice that occur. 3. **Check** regularly server's error_log for notices/warnings
+2. **Fix** every warning or notice that occurs.
+
+3. **Check** regularly server's error_log for notices/warnings
 
 4. Identify any **temporary hack** with a special **mark**. Maybe something like:
 
-```
+```php
 #@TODO masterpiece by @smartguy, to quick fix the division by zero
 ```
 
- 
-
-5. Each **function** must do a **single task**. If is log in the user and record the login in stats table, be nice and create a separate function for 'record the login' stuff. Maybe even a **distinct class** for stats ?
+5. Each **function** must do a **single task**. If is log in the user and record the login in stats table, be nice and create a separate function for 'record the login' stuff. Maybe even a **distinct class** for stats?
 
 6. Use a version control system. **SVN is NOT dead.**
 
-7. Use an **[IDE](http://en.wikipedia.org/wiki/Integrated_development_environment)**.  [Aptana 2](http://www.aptana.com/products/studio2/download), [Aptana 3](http://www.aptana.com/products/studio3/download), Eclipse, even [Zend Studio](http://www.zend.com/en/products/studio/) .
+7. Use an **[IDE](http://en.wikipedia.org/wiki/Integrated_development_environment)**. [Aptana 2](http://www.aptana.com/products/studio2/download), [Aptana 3](http://www.aptana.com/products/studio3/download), Eclipse, even [Zend Studio](http://www.zend.com/en/products/studio/).
 
 8. Know your **IDE**: code snippets, code assist, integration with Zend Framework, SVN integration, bug tracker integration, and so on
 
@@ -47,7 +47,15 @@ A: Fix every warning or notice that occurs, and regularly check the server's err
 A: Identify any temporary hack with a special mark, such as a #@TODO comment noting who added it and why.
 
 **Q: What is the rule about what a function should do?**
-A: Each function must do a single task. For example, if you're logging in a user and also recording that login in a stats table, create a separate function (or even a distinct class) for the stats recording, rather than combining both tasks in one function.
+A: Each function must do a single task.
+For example, if you're logging in a user and also recording that login in a stats table, create a separate function (or even a distinct class) for the stats recording, rather than combining both tasks in one function.
 
 **Q: What tools does the article recommend for professional PHP development?**
 A: It recommends using a version control system (noting that SVN is not dead) and using an IDE such as Aptana 2, Aptana 3, Eclipse, or Zend Studio, and knowing your IDE's code snippets, code assist, Zend Framework integration, SVN integration, and bug tracker integration.
+
+## Resources
+
+- [Integrated development environment (Wikipedia)](http://en.wikipedia.org/wiki/Integrated_development_environment)
+- [Aptana 2 download](http://www.aptana.com/products/studio2/download)
+- [Aptana 3 download](http://www.aptana.com/products/studio3/download)
+- [Zend Studio](http://www.zend.com/en/products/studio/)
diff --git a/public/md-articles/best-practice/htaccess-301-redirect-non-www-to-www.md b/public/md-articles/best-practice/htaccess-301-redirect-non-www-to-www.md
index 04d2c362..aa164852 100644
--- a/public/md-articles/best-practice/htaccess-301-redirect-non-www-to-www.md
+++ b/public/md-articles/best-practice/htaccess-301-redirect-non-www-to-www.md
@@ -12,14 +12,14 @@ language: "en"
 
 To always redirect users to the www site (for example: http://dotboost.com to http://www.dotboost.com), add the following lines to .htaccess, right after **RewriteEngine On**:
 
-```
+```shell
 RewriteCond %{HTTP_HOST} ^dotboost.com
 RewriteRule ^(.*)$ http://www.dotboost.com/$1 [L,R=301]
 ```
 
 If, on the other hand, you want to redirect http://www.dotboost.com to http://dotboost.com, add the following lines instead:
 
-```
+```shell
 RewriteCond %{HTTP_HOST} ^www.dotboost.com
 RewriteRule ^(.*)$ http://dotboost.com/$1 [L,R=301]
 ```
diff --git a/public/md-articles/best-practice/insert-update-delete-statements-with-zend-db.md b/public/md-articles/best-practice/insert-update-delete-statements-with-zend-db.md
index 4205a50f..79e45302 100644
--- a/public/md-articles/best-practice/insert-update-delete-statements-with-zend-db.md
+++ b/public/md-articles/best-practice/insert-update-delete-statements-with-zend-db.md
@@ -11,31 +11,30 @@ language: "en"
 # INSERT, UPDATE, DELETE statements with Zend_Db
 
 ## TL;DR
+
 DML (Data Manipulation Language) statements change data values in database tables.
 This article, continuing the Zend_Db series, shows how the three primary DML statements - INSERT, UPDATE, and DELETE - are written in raw SQL and translated into Zend_Db method calls.
 
 Continuing the Zend_DB article [series](http://www.dotkernel.com/dotkernel/sql-queries-using-zend-db-select/), we are stopping now at DML statements. DML (Data Manipulation Language) statements are statements that change data values in database tables. There are 3 primary DML statements:
 
 - INSERT - Inserting new rows into database tables.
-- UPDATE - Updating existing rows in database tables .
+- UPDATE - Updating existing rows in database tables.
 - DELETE - Deleting existing rows from database tables.
 
-*Note*:*
-
-```
+```php
 $db = Zend_Db::factory('Pdo_Mysql', $dbConnect);
 ```
 
 **INSERT**
 
-```
+```sql
 INSERT INTO user(email, password, firstName, lastName, active)
        VALUES ('$email', '$password', '$firstName', '$lastName', 1);
 ```
 
-The above SQL *INSERT* statement is translated in Zend_Db as follow:
+The above SQL *INSERT* statement is translated in Zend_Db as follows:
 
-```
+```php
 $data = array( 'email' => $email,
             'password' => $password,
             'firstName' => $firstName,
@@ -46,7 +45,7 @@ $db->insert('user', $data);
 
 **UPDATE**
 
-```
+```sql
 UPDATE user
    SET password = '$password',
        firstName = '$firstName',
@@ -55,9 +54,9 @@ UPDATE user
  WHERE id = '$id'
 ```
 
-The above SQL *UPDATE* statemnet is translated in Zend_Db as follow:
+The above SQL *UPDATE* statement is translated in Zend_Db as follows:
 
-```
+```php
 $data = array('password' => $password,
               'firstName' => $firstName,
               'lastName' => $vlastname,
@@ -67,26 +66,32 @@ $db->update('user', $data, 'id = '.$id);
 
 **DELETE**
 
-```
+```sql
 DELETE FROM user WHERE id = '$id'
 ```
 
-The above SQL *DELETE* statemnet is translated in Zend_Db as follow:
+The above SQL *DELETE* statement is translated in Zend_Db as follows:
 
-```
+```php
 $db->delete('user', 'id = '.$id);
 ```
 
 ## FAQ
 
 **Q: What are DML statements?**
-A: DML (Data Manipulation Language) statements are statements that change data values in database tables. There are 3 primary DML statements: INSERT, UPDATE, and DELETE.
+A: DML (Data Manipulation Language) statements are statements that change data values in database tables.
+There are 3 primary DML statements: INSERT, UPDATE, and DELETE.
 
 **Q: How do you insert a new row with Zend_Db?**
-A: Build an associative array of column names to values (e.g. email, password, firstName, lastName, active) and pass it to $db->insert('user', $data), which corresponds to an SQL INSERT INTO ... VALUES statement.
+A: Build an associative array of column names to values (e.g. email, password, firstName, lastName, active) and pass it to $db->insert('user', $data), which corresponds to an SQL INSERT INTO ...
+VALUES statement.
 
 **Q: How do you update rows with Zend_Db, including incrementing a column?**
 A: Build a $data array of the columns to update, using a Zend_Db_Expr for expressions such as incrementing accountUpdate (new Zend_Db_Expr('accountUpdate+1')), then call $db->update('user', $data, 'id = '.$id).
 
 **Q: How do you delete a row with Zend_Db?**
 A: Call $db->delete('user', 'id = '.$id), which is equivalent to the SQL statement DELETE FROM user WHERE id = '$id'.
+
+## Resources
+
+- [Zend_Db series](http://www.dotkernel.com/dotkernel/sql-select-zend-db/)
diff --git a/public/md-articles/best-practice/sql-queries-using-zend-db-select.md b/public/md-articles/best-practice/sql-queries-using-zend-db-select.md
index c20ad343..f68ff064 100644
--- a/public/md-articles/best-practice/sql-queries-using-zend-db-select.md
+++ b/public/md-articles/best-practice/sql-queries-using-zend-db-select.md
@@ -11,12 +11,13 @@ language: "en"
 # SQL queries using Zend_Db - SELECT
 
 ## TL;DR
+
 Zend_Db and its related classes provide a simple SQL database interface for Zend Framework.
 This article shows how classical SELECT queries with JOINs and WHERE IN clauses are translated into Zend_Db's select() style, and how to debug the generated query.
 
-[Zend_Db](https://docs.laminas.dev/laminas-db/adapter/) and its related classes provide a simple SQL database interface for Zend Framework. To connect to MySql database, we are using Pdo_Mysql adapter :
+[Zend_Db](https://docs.laminas.dev/laminas-db/adapter/) and its related classes provide a simple SQL database interface for Zend Framework. To connect to MySQL database, we are using Pdo_Mysql adapter :
 
-```
+```php
 $db = Zend_Db::factory('Pdo_Mysql', $dbConnect);
 ```
 
@@ -24,22 +25,22 @@ $db = Zend_Db::factory('Pdo_Mysql', $dbConnect);
 
 The below 2 classical SQL queries are equivalent. First one is simple, the second one use INNER JOIN keyword, but the result is the same.
 
-```
+```sql
 SELECT a.id, a.name, b.order_id
 FROM users AS a, orders AS b
 WHERE a.id = b.user_id
 AND a.id = {$userId}
 ```
 
-```
+```sql
 SELECT `a`.`id`, `a`.`name`, `b`.`order_id`
 FROM `users` AS `a` INNER JOIN `orders` AS `b` ON a.id = b.user_id
 WHERE (a.id = '{$userId}')
 ```
 
-The above querys are translated in Zend_Db style:
+The above queries are translated in Zend_Db style:
 
-```
+```php
 $select = $db->select()
              ->from(array('a'=>'users'),
                     array('a.id', 'a.name'))
@@ -49,15 +50,14 @@ $select = $db->select()
 
 If we don't want to select any column from the second table, the 3rd parameter of join() method should be an empty string
 
-```
+```sql
 SELECT a.id, a.name
 FROM users AS a, orders AS b
 WHERE a.id = b.user_id
 AND a.id = {$userId}
 ```
 
-```
- >
+```php
 $select = $db->select()
              ->from(array('a'=>'users'),
                     array('a.id', 'a.name'))
@@ -65,17 +65,16 @@ $select = $db->select()
              ->where('a.id = ?', $userId)
 ```
 
-Note*: If we don't write the 3rd parameter, it will select all the fields from that table:
+Note: If we don't write the 3rd parameter, it will select all the fields from that table:
 
-```
+```sql
 SELECT a.id, a.name, b.*
 FROM users AS a, orders AS b
 WHERE a.id = b.user_id
 AND a.id = {$user_id}
 ```
 
-```
- >
+```php
 $select = $db->select()
              ->from(array('a'=>'users'),
                     array('a.id', 'a.name'))
@@ -85,31 +84,29 @@ $select = $db->select()
 
 **SELECT query - WHERE IN clause**
 
-```
+```sql
 SELECT id
 FROM users
 WHERE aff_id IN ('1','2','3')
 ```
 
-```
- >
+```php
 $select = $db->select()
              ->from('users', array('id'))
              ->where('aff_id IN (?)', array(1,2,3));
 ```
 
-**Note*:** If you are not sure if you write the correct query, before you fetch it you can echo your query to visualize it:
+**Note**: If you are not sure if you write the correct query, before you fetch it you can echo your query to visualize it:
 
-```
+```php
 echo $select->__toString();exit;
 ```
 
-Also see: - [What are returning the FETCH functions from Zend_Db](http://www.dotkernel.com/best-practice/what-are-returning-the-fetch-functions-from-zend-db/) - [Subqueries with Zend_Db](http://www.dotkernel.com/best-practice/subqueries-with-zend-db/) - [INSERT, UPDATE, DELETE statements with Zend_Db](http://www.dotkernel.com/best-practice/insert-update-delete-statements-with-zend-db/)
-
 ## FAQ
 
 **Q: What does Zend_Db provide?**
-A: Zend_Db and its related classes provide a simple SQL database interface for Zend Framework. To connect to a MySQL database, the Pdo_Mysql adapter is used via Zend_Db::factory('Pdo_Mysql', $dbConnect).
+A: Zend_Db and its related classes provide a simple SQL database interface for Zend Framework.
+To connect to a MySQL database, the Pdo_Mysql adapter is used via Zend_Db::factory('Pdo_Mysql', $dbConnect).
 
 **Q: How do you write a SELECT with a JOIN and a WHERE clause in Zend_Db style?**
 A: Use $db->select()->from(array('a'=>'users'), array('a.id','a.name'))->join(array('b'=>'orders'), 'a.id = b.user_id', array('b.order_id'))->where('a.id = ?', $userId), which is equivalent to a classical SQL query using INNER JOIN.
@@ -125,3 +122,10 @@ A: Use ->where('aff_id IN (?)', array(1,2,3)) on the select object, equivalent t
 
 **Q: How can you check that a Zend_Db select is generating the correct query?**
 A: Before fetching it, echo the query to visualize it: echo $select->__toString();exit;
+
+## Resources
+
+- [Zend_Db](https://docs.laminas.dev/laminas-db/adapter/)
+- [What are returning the FETCH functions from Zend_Db](http://www.dotkernel.com/best-practice/what-are-returning-the-fetch-functions-from-zend-db/)
+- [Subqueries with Zend_Db](http://www.dotkernel.com/best-practice/subqueries-with-zend-db/)
+- [INSERT, UPDATE, DELETE statements with Zend_Db](http://www.dotkernel.com/best-practice/insert-update-delete-statements-with-zend-db/)
diff --git a/public/md-articles/best-practice/subqueries-with-zend-db.md b/public/md-articles/best-practice/subqueries-with-zend-db.md
index 3aefa608..f3a0f7ae 100644
--- a/public/md-articles/best-practice/subqueries-with-zend-db.md
+++ b/public/md-articles/best-practice/subqueries-with-zend-db.md
@@ -11,13 +11,14 @@ language: "en"
 # Subqueries with Zend_Db
 
 ## TL;DR
+
 Continuing the Zend_Db series, this article shows a more complex query - combining COUNT(), LEFT JOIN, and GROUP BY across 3 tables, with a count taken from 2 different tables - and how to build it, including a nested subquery, using Zend_Db.
 
 Continuing the Zend_DB article [series](http://www.dotkernel.com/dotkernel/sql-queries-using-zend-db-select/), we are stopping now at subqueries.
 
 As you note, the below is a complicate query, with *COUNT()*, *LEFT JOIN()*, *GROUP BY* - select from 3 tables, and make a count from 2 different tables:
 
-```
+```sql
 SELECT a.id,
        a.title,
        (SELECT COUNT(c.track_id)
@@ -30,13 +31,13 @@ LEFT JOIN track_courses AS b ON (a.id = b.track_id)
 GROUP BY a.id
 ```
 
-Initialize the connection to our MySql database:
+Initialize the connection to the MySQL database:
 
-```
+```php
 $db = Zend_Db::factory('Pdo_Mysql', $dbConnect);
 ```
 
-```
+```php
 $db->select()
    ->from(array('a'=>'tracks'),
          array('id',
@@ -65,3 +66,7 @@ A: Wrap a nested $db->select() call inside a Zend_Db_Expr, building the subquery
 
 **Q: How is the LEFT JOIN with a COUNT expressed in Zend_Db?**
 A: Use ->joinLeft(array('b'=>'track_courses'), 'a.id = b.track_id', array('count_courses' => 'COUNT(b.track_id)')) followed by ->group('a.id').
+
+## Resources
+
+- [Zend_Db series](http://www.dotkernel.com/dotkernel/sql-select-zend-db/)
diff --git a/public/md-articles/best-practice/svn-export-in-a-virtual-host.md b/public/md-articles/best-practice/svn-export-in-a-virtual-host.md
index f7386f40..0286abf1 100644
--- a/public/md-articles/best-practice/svn-export-in-a-virtual-host.md
+++ b/public/md-articles/best-practice/svn-export-in-a-virtual-host.md
@@ -11,12 +11,13 @@ language: "en"
 # SVN Export in a virtual host
 
 ## TL;DR
+
 `svn export` lets you export the contents of a repository into a virtual host directory.
 The commands should be run in a terminal (e.g. via Putty on Windows) on the target host, ideally using the domain's own user rather than root.
 
 The following commands should be run in the terminal (for example, using Putty in Windows) on the host where you want to export the repository). It's recommended that you run them using the domain's user, not root.
 
-First make sure that Subversion is installed on the host. To check if it is installed, run:
+1. First make sure that Subversion is installed on the host. To check if it is installed, run:
 
 ```
 svn --version
@@ -24,44 +25,46 @@ svn --version
 
 If you don't get a "command not found" message, subversion is installed. Otherwise, you need to install it.
 
-The next step is to go to where you want to export the contents of the repository (eg.: "*cd /var/www/vhosts/example.com/httpdocs*" or "*cd /home/sitename/public_html*").
+2. The next step is to go to where you want to export the contents of the repository (eg.: "*cd /var/www/vhosts/example.com/httpdocs*" or "*cd /home/sitename/public_html*").
 
-The command looks like this:
+3. The command looks like this:
 
-```
+```shell
 svn export repositoryUrl repositoryUrl
 ```
 
 where:
 
-- **-r revisionNumber** - *optional* - export a specific revision. By default, the latest revision will be used
-- **repositoryUrl** - the repository URL (eg: *http://example.com/repos/project-name/trunk/*). Remember to add /trunk/, or change it appropriately if you need to export a certain branch or tag
-- **targetDirectory**
-  - **./** - means the current directory
-  - **./project-name** - will export to the *project-name* subdirectory
-  - **/var/www/vhosts/example.com/httpdocs** - will export to an absolute path
-- **--force** - *optional* - by default SVN will not export in an existing directory. if you want to override this, you have to use the *force* parameter. **Be careful, this option can overwrite files**
+| Parameter | Meaning |
+|---|---|
+| `-r revisionNumber` | Optional. Exports a specific revision. By default, the latest revision is used. |
+| `repositoryUrl` | The repository URL (e.g. `http://example.com/repos/project-name/trunk/`). Remember to add `/trunk/`, or change it appropriately for a branch or tag. |
+| `targetDirectory` - `./` | The current directory. |
+| `targetDirectory` - `./project-name` | Exports to the `project-name` subdirectory. |
+| `targetDirectory` - `/var/www/vhosts/example.com/httpdocs` | Exports to an absolute path. |
+| `--force` | Optional. By default SVN will not export into an existing directory; this overrides that. **Be careful, this option can overwrite files.** |
+
+4. For more information, you can run **svn help export**.
 
 Examples:
 
-```
+```shell
 svn export http://v1.dotkernel.net/svn/trunk ./ --force
 svn export -r 423 http://v1.dotkernel.net/svn/trunk ./ --force
 svn export http://v1.dotkernel.net/svn/trunk /var/www/vhosts/domain.com/httpdocs/dk
 ```
 
-For more information, you can run **svn help export**.
-
 If you've exported the repository using a different user (root for example), you can change the permissions back by running the following command as root:
 
-```
+```shell
 chown -R siteuser.psacln /var/www/vhosts/example.com/httpdocs
 ```
 
 ## FAQ
 
 **Q: How do you check if Subversion is installed on the host?**
-A: Run svn --version. If you don't get a "command not found" message, Subversion is installed; otherwise, you need to install it.
+A: Run svn --version.
+If you don't get a "command not found" message, Subversion is installed; otherwise, you need to install it.
 
 **Q: What is the basic command to export a repository?**
 A: The command is svn export repositoryUrl targetDirectory, run from the host where you want to export the repository, ideally using the domain's user rather than root.
@@ -70,7 +73,8 @@ A: The command is svn export repositoryUrl targetDirectory, run from the host wh
 A: -r revisionNumber is optional and exports a specific revision; by default, the latest revision is used.
 
 **Q: What does the --force option do, and what is the risk?**
-A: By default SVN will not export into an existing directory; --force overrides this. Be careful, since this option can overwrite files.
+A: By default SVN will not export into an existing directory; --force overrides this.
+Be careful, since this option can overwrite files.
 
 **Q: How do you fix file permissions if you exported the repository as a different user?**
 A: As root, run chown -R siteuser.psacln /var/www/vhosts/example.com/httpdocs to change the permissions back.
diff --git a/public/md-articles/best-practice/svn-keywords-setup-in-php-ide-zend-studio.md b/public/md-articles/best-practice/svn-keywords-setup-in-php-ide-zend-studio.md
index ec9e7cf5..3b39e348 100644
--- a/public/md-articles/best-practice/svn-keywords-setup-in-php-ide-zend-studio.md
+++ b/public/md-articles/best-practice/svn-keywords-setup-in-php-ide-zend-studio.md
@@ -11,14 +11,17 @@ language: "en"
 # SVN keywords setup in PHP IDE ( Zend Studio)
 
 ## TL;DR
+
 For better integration between SVN, the Zend Studio PHP IDE, and a bug tracker, a set of SVN properties must be set for each project.
 This article lists which properties to set and how.
 
 For a better integration of SVN, your PHP IDE( Zend Studio), and a bug tracker of choice, the below proprieties must be set, **for each project** you have.
 
-Right click on **project** Go to **Team->Set Propriety**
+1. Right click on **project**.
+
+2. Go to **Team->Set Propriety**.
 
-- SVN Ignore files, below you have an example. As we do not want to commit your local settings to the main repository :-)
+3. SVN Ignore files, below you have an example. As we do not want to commit your local settings to the main repository :-)
 
 ```
 Name: svn:ignore
@@ -32,7 +35,7 @@ cache
 *.ini
 ```
 
-- Basic integration with a bug tracker
+4. Basic integration with a bug tracker
 
 ```
 Name: bugtracq:label
@@ -44,7 +47,7 @@ Name: bugtraq:message
 Propriety: [Tracker ID: #%BUGID%]
 ```
 
-- If you have a public bug tracker system , example Mantis
+5. If you have a public bug tracker system, example Mantis
 
 ```
 Name: bugtraq:url
@@ -55,9 +58,9 @@ For **above** Proprieties , apply **only** to project folder, **NOT** recursive
 
 ## Final step( below instructions are good **only** for **svn:keywords** )
 
- 
-
-Check the **Apply property recursively to:** Select **All resources** Check the **Use filtration by the resource name** and add **Mask:** *.php
+1. Check the **Apply property recursively to:**.
+2. Select **All resources**.
+3. Check the **Use filtration by the resource name** and add **Mask:** *.php.
 
 [![svn-add](/uploads/article/019f8a80-cc87-71b3-80b8-478826d88044/svn-add.jpg)](/uploads/2013/02/svn-add.jpg)
 
diff --git a/public/md-articles/best-practice/using-like-wildcards-with-zend-db.md b/public/md-articles/best-practice/using-like-wildcards-with-zend-db.md
index b89d59e3..6785a335 100644
--- a/public/md-articles/best-practice/using-like-wildcards-with-zend-db.md
+++ b/public/md-articles/best-practice/using-like-wildcards-with-zend-db.md
@@ -11,6 +11,7 @@ language: "en"
 # Using LIKE wildcards with Zend_Db
 
 ## TL;DR
+
 The LIKE condition allows pattern matching in the WHERE clause of SELECT, INSERT, UPDATE, or DELETE statements.
 The `_` wildcard matches a single character, and `%` matches any string of any length (including zero).
 This article shows how to use LIKE and NOT LIKE with both wildcards in Zend_Db.
@@ -24,9 +25,7 @@ The **LIKE** condition allows you to use wildcards in the *WHERE* clause of an S
 - ***_*** allows you to match a single character
 - ***%*** allows you to match any string of any length (including zero length)
 
-*Note*:*
-
-```
+```php
 $db = Zend_Db::factory('Pdo_Mysql', $dbConnect);
 ```
 
@@ -34,11 +33,11 @@ $db = Zend_Db::factory('Pdo_Mysql', $dbConnect);
 
 - Return all ids which start with '1' and second digit is between 0 and 9 (10, 11, 12, ..., 18, 19):
 
-```
+```sql
 SELECT * FROM `table` WHERE (`id` LIKE '1_' )
 ```
 
-```
+```php
 $col = $this->db->quoteIdentifier('id');
 $where = $this->db->quoteInto("$col LIKE ? ", '1_');
 $select = $this->db->select()
@@ -47,13 +46,13 @@ $select = $this->db->select()
 $result = $this->db->fetchAll($select);
 ```
 
-- Return all instances whose name is 4 characters long, where the first two characters are 'Fr' and the last character is 'd' (Frad, Fred, Frod, etc.) :
+- Return all instances whose name is 4 characters long, where the first two characters are 'Fr' and the last character is 'd' (Frad, Fred, Frod, etc.):
 
-```
+```sql
 SELECT * FROM `table` WHERE (`name` LIKE 'Fr_d' )
 ```
 
-```
+```php
 $col = $this->db->quoteIdentifier('name');
 $where = $this->db->quoteInto("$col LIKE ? ", 'Fr_d');
 $select = $this->db->select()
@@ -66,11 +65,11 @@ $result = $this->db->fetchAll($select);
 
 - Returns all instances that have the 'gallery' string in the *source* field:
 
-```
+```sql
 SELECT * FROM `table` WHERE (`source` LIKE '%gallery%' )
 ```
 
-```
+```php
 $col = $this->db->quoteIdentifier('source');
 $where = $this->db->quoteInto("$col LIKE ? ", '%gallery%');
 $select = $this->db->select()
@@ -81,11 +80,11 @@ $result = $this->db->fetchAll($select);
 
 - Returns all instances that have the 'gallery' or 'folder' strings in the *source* field:
 
-```
+```sql
 SELECT * FROM `table` WHERE (`source` LIKE '%gallery%' OR `source` LIKE ('%folder%') )
 ```
 
-```
+```php
 $col = $this->db->quoteIdentifier('source');
 $where = $this->db->quoteInto("$col LIKE ? ", '%gallery%');
 $where .= $this->db->quoteInto("OR $col LIKE (?) ", '%folder%');
@@ -97,13 +96,13 @@ $result = $this->db->fetchAll($select);
 
 **NOT LIKE _**
 
-- Returns all 2-digit ids that don't start with *1* (20->99 ) or have a different number of digits than 2 (1, 2, ..., 8, 9, 100, 101, ...):
+- Returns all 2-digit ids that don't start with *1* (20->99) or have a different number of digits than 2 (1, 2, ..., 8, 9, 100, 101, ...):
 
-```
+```sql
 SELECT * FROM `table` WHERE (`id` NOT LIKE '1_' )
 ```
 
-```
+```php
 $col = $this->db->quoteIdentifier('id');
 $where = $this->db->quoteInto("$col NOT LIKE ? ", '1_');
 $select = $this->db->select()
@@ -116,11 +115,11 @@ $result = $this->db->fetchAll($select);
 
 - Returns all instances that don't have 'gallery', 'folder' or 'file' strings in the *source* field:
 
-```
+```sql
 SELECT * FROM `table` WHERE (`source` NOT LIKE ('%gallery%') AND `source` NOT LIKE ('%folder%') AND `source` NOT LIKE ('%file%') )
 ```
 
-```
+```php
 $col = $this->db->quoteIdentifier('source');
 $where = $this->db->quoteInto("$col NOT LIKE (?) ", '%gallery%');
 $where .= $this->db->quoteInto("AND $col NOT LIKE (?) ", '%folder%');
@@ -131,13 +130,13 @@ $select = $this->db->select()
 $result = $this->db->fetchAll($select);
 ```
 
-**OTHER Example**
+**Other example**
 
-```
-SELECT * FROM `table` WHERE `number` LIKE '_6%' 
+```sql
+SELECT * FROM `table` WHERE `number` LIKE '_6%'
 ```
 
-```
+```php
 $col = $this->db->quoteIdentifier('number');
 $where = $this->db->quoteInto("$col LIKE ? ", '_6%');
 $select = $this->db->select()
@@ -160,10 +159,12 @@ A: The _ wildcard matches a single character, while % matches any string of any
 A: LIKE allows pattern matching in the WHERE clause and can be used in any valid SQL statement: SELECT, INSERT, UPDATE, or DELETE.
 
 **Q: How do you build a LIKE query with Zend_Db?**
-A: Quote the column with $this->db->quoteIdentifier(), build the condition with $this->db->quoteInto("$col LIKE ? ", $pattern), and pass the resulting $where string into ->where() on a select, then run it with $this->db->fetchAll($select).
+A: Quote the column with $this->db->quoteIdentifier(), build the condition with $this->db->quoteInto("$col LIKE ?
+", $pattern), and pass the resulting $where string into ->where() on a select, then run it with $this->db->fetchAll($select).
 
 **Q: How do you combine multiple LIKE conditions with OR?**
-A: Build the first condition with quoteInto, then append further ones with quoteInto("OR $col LIKE (?) ", $pattern), as in the example matching 'gallery' or 'folder' in the source field.
+A: Build the first condition with quoteInto, then append further ones with quoteInto("OR $col LIKE (?)
+", $pattern), as in the example matching 'gallery' or 'folder' in the source field.
 
 **Q: How does NOT LIKE differ from LIKE?**
 A: NOT LIKE negates the pattern match — for example, `id` NOT LIKE '1_' returns ids that don't start with 1 or don't have exactly 2 digits, and NOT LIKE conditions can be chained with AND to exclude several patterns at once.
diff --git a/public/md-articles/best-practice/what-are-returning-the-fetch-functions-from-zend-db.md b/public/md-articles/best-practice/what-are-returning-the-fetch-functions-from-zend-db.md
index 020c45aa..5fcb03d3 100644
--- a/public/md-articles/best-practice/what-are-returning-the-fetch-functions-from-zend-db.md
+++ b/public/md-articles/best-practice/what-are-returning-the-fetch-functions-from-zend-db.md
@@ -11,45 +11,50 @@ language: "en"
 # What are returning the FETCH functions from Zend_Db
 
 ## TL;DR
+
 Continuing the Zend_Db article series, this article walks through the FETCH methods available on Zend_Db_Adapter_Abstract: fetchAll, fetchAssoc, fetchCol, fetchOne, fetchPairs, and fetchRow.
 Each method is shown next to the equivalent old-style code built on query(), next_record(), and f(), so the two approaches can be compared side by side.
 
 Continuing the Zend_DB article [series](http://www.dotkernel.com/dotkernel/sql-queries-using-zend-db-select/), we are stopping now at *FETCH* methods that are in [Zend_Db_Adapter_Abstract](https://docs.laminas.dev/laminas-db/adapter/):
 
-```
-array  fetchAll  (string|Zend_Db_Select $sql, , )
-array fetchAssoc (string|Zend_Db_Select $sql, [mixed $bind = array()])
-array fetchCol (string|Zend_Db_Select $sql, [mixed $bind = array()])
-string fetchOne (string|Zend_Db_Select $sql, [mixed $bind = array()])
-array fetchPairs (string|Zend_Db_Select $sql, [mixed $bind = array()])
-array fetchRow (string|Zend_Db_Select $sql, , )
+```php
+array  fetchAll   (string|Zend_Db_Select $sql, [mixed $bind = array()])
+array  fetchAssoc (string|Zend_Db_Select $sql, [mixed $bind = array()])
+array  fetchCol   (string|Zend_Db_Select $sql, [mixed $bind = array()])
+string fetchOne   (string|Zend_Db_Select $sql, [mixed $bind = array()])
+array  fetchPairs (string|Zend_Db_Select $sql, [mixed $bind = array()])
+array  fetchRow   (string|Zend_Db_Select $sql, [mixed $bind = array()])
 ```
 
 To be more easily to follow, in green box is the classical SQL statement, and in blue box is the query written in Zend_Db style.
 
-Lets start. Initialize the connection to our MySql database:
+Initialize the connection to the MySQL database:
 
-```
+```php
 $db = Zend_Db::factory('Pdo_Mysql', $dbConnect);
 ```
 
-Here is a SQL query, that we want to fetch:
+Here is a SQL query that we want to fetch:
 
-```
+```sql
 $sql = "SELECT id, title FROM files";
 $db->query($sql)
 ```
 
-```
+```php
 $select = $db->select()
              ->from('files', array('id', 'title'))
 ```
 
-*Note*:* for the old style of fetching we used an old class. What you need to know is: - *query()* method is similar with mysqli_query() from *Mysqli* PHP extension - *next_record()* method is similar with mysqli_next_result() from *Mysqli* PHP extension - *f()* method retrieve the value of the column specified as parameter
+Note: for the old style of fetching we used an old class. What you need to know is:
+
+- *query()* method is similar with mysqli_query() from *Mysqli* PHP extension
+- *next_record()* method is similar with mysqli_next_result() from *Mysqli* PHP extension
+- *f()* method retrieve the value of the column specified as parameter
 
 **fetchAll**
 
-```
+```php
 while($db->next_record())
 {
     $a[] = array(
@@ -59,13 +64,13 @@ while($db->next_record())
 }
 ```
 
-```
+```php
 $a = $db->fetchAll($select);
 ```
 
 **fetchAssoc**
 
-```
+```php
 while($db->next_record())
 {
     $a[$db->f('id')] = array(
@@ -75,50 +80,50 @@ while($db->next_record())
 }
 ```
 
-```
+```php
 $a = $db->fetchAssoc($select);
 ```
 
 **fetchCol**
 
-```
+```php
 while($db->next_record())
 {
     $a[] = $db->f('id');
 }
 ```
 
-```
+```php
 $a = $db->fetchCol($select);
 ```
 
 **fetchOne**
 
-```
+```php
 $db->next_record();
 $a = $db->f('id');
 ```
 
-```
+```php
 $a = $db->fetchOne($select);
 ```
 
 **fetchPairs**
 
-```
+```php
 while($db->next_record())
 {
     $a[$db->f('id')] = $db->f('title');
 }
 ```
 
-```
+```php
 $a = $db->fetchPairs($select);
 ```
 
 **fetchRow**
 
-```
+```php
 $db->next_record();
 $a = array(
            'id' => $db->f('id'),
@@ -126,7 +131,7 @@ $a = array(
           );
 ```
 
-```
+```php
 $a = $db->fetchRow($select);
 ```
 
diff --git a/public/md-articles/best-practice/why-use-current-timestamp-on-a-field-that-record-date-time.md b/public/md-articles/best-practice/why-use-current-timestamp-on-a-field-that-record-date-time.md
index 1f9c909e..07110f6d 100644
--- a/public/md-articles/best-practice/why-use-current-timestamp-on-a-field-that-record-date-time.md
+++ b/public/md-articles/best-practice/why-use-current-timestamp-on-a-field-that-record-date-time.md
@@ -11,19 +11,20 @@ language: "en"
 # Why use CURRENT_TIMESTAMP on a field that record date/time?
 
 ## TL;DR
+
 On a TIMESTAMP field that records date and time when inserting a new record, it's encouraged to use the CURRENT_TIMESTAMP constant as its DEFAULT value.
 This removes the need to set the value manually from PHP or with MySQL's NOW() function, and the ON UPDATE CURRENT_TIMESTAMP clause can additionally keep the field updated automatically on every row update.
 Only one TIMESTAMP field per table can be DEFAULT CURRENT_TIMESTAMP.
 
 On a *TIMESTAMP field* that records date and time when *inserting* a new record, it is encouraged to use as a *DEFAULT* value, the **CURRENT_TIMESTAMP** constant. **Why?** Because when inserting a new row in the table for the date and time field there is no need to specifically add its value, either by creating it from PHP code with the [Date/ Time functions](http://www.php.net/manual/en/ref.datetime.php) or with MySQL function [NOW()](http://dev.mysql.com/doc/refman/5.0/en/date-and-time-functions.html#function_now)
 
-```
+```sql
 ALTER TABLE `user` CHANGE `dateCreated` `dateCreated` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP;
 ```
 
-CURRENT_TIMESTAMP is also a solution for  *updating* date and time fields. Use *`ON UPDATE CURRENT_TIMESTAMP`* clause, if you want the value of the field to be changed automatically each time the row is updated.
+CURRENT_TIMESTAMP is also a solution for *updating* date and time fields. Use *`ON UPDATE CURRENT_TIMESTAMP`* clause, if you want the value of the field to be changed automatically each time the row is updated.
 
-```
+```sql
 ALTER TABLE `user` CHANGE `dateLogin` `dateLogin` TIMESTAMP ON UPDATE CURRENT_TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP;
 ```
 
@@ -37,7 +38,7 @@ ALTER TABLE `user` CHANGE `dateLogin` `dateLogin` TIMESTAMP ON UPDATE CURRENT_TI
 
 For more details check out [MySQL Manual](https://dev.mysql.com/doc/refman/9.7/en/datetime.html)
 
-**Note*:** Only one timestamp field can be `DEFAULT CURRENT_TIMESTAMP` in a table.
+**Note**: Only one timestamp field can be `DEFAULT CURRENT_TIMESTAMP` in a table.
 
 ## FAQ
 
diff --git a/public/md-articles/best-practice/zf-is-retired-laminas-mvc-is-retiring-consider-it-solved.md b/public/md-articles/best-practice/zf-is-retired-laminas-mvc-is-retiring-consider-it-solved.md
index 58439378..fbcfd46f 100644
--- a/public/md-articles/best-practice/zf-is-retired-laminas-mvc-is-retiring-consider-it-solved.md
+++ b/public/md-articles/best-practice/zf-is-retired-laminas-mvc-is-retiring-consider-it-solved.md
@@ -11,6 +11,7 @@ language: "en"
 # ZF Is Retired. Laminas MVC Is Retiring. Consider It Solved
 
 ## TL;DR
+
 Laminas MVC is retiring, following Zend Framework and Apigility before it, but this doesn't mean everything with a Laminas logo is going away - Mezzio, built on Laminas components, is the fully-functional successor.
 Maintaining legacy MVC platforms is costly and risky long-term, since the architecture of today and tomorrow is middleware-based, and Apidemia offers a proven, phased migration process to move legacy platforms to Mezzio.
 
@@ -22,13 +23,13 @@ Laminas MVC is not even the first framework that has reached its end of life - l
 
 ## What Is the Issue with Legacy Platforms?
 
-**Maintaining legacy platforms** over the long term is often a **costly** and **time-consuming** endeavour. Every few years, platform **owners** must consider the viablity of **migrating to a newer platform**.
+**Maintaining legacy platforms** over the long term is often a **costly** and **time-consuming** endeavour. Every few years, platform **owners** must consider the viability of **migrating to a newer platform**.
 
 Newer platforms implement **modern architectures**, have an **active community** and are actively being **developed and maintained**. They also offer **easier development, expansion and maintenance**, alongside vital **security improvements** and more **reliable dependencies**.
 
 Sounds like an easy decision? Sure, but it's a lot of work... And that's when the specialists come into play.
 
-We at Apidemia have been using the Zend Framework, Laminas MVC and Mezzio for years. We understand their ins-and-outs intimately, which enables us to **analyze and to perform the transfer of a legacy platform to Mezzio effectively**. Working with Mezzio ensures faster execution times, increased security, faster development and long-term reliability from all points of view. We encourage this change and are ready to offer guidance.
+We at Apidemia have been using the Zend Framework, Laminas MVC and Mezzio for years. We understand their ins-and-outs intimately, which enables us to **analyze and perform the transfer of a legacy platform to Mezzio effectively**. Working with Mezzio ensures faster execution times, increased security, faster development and long-term reliability from all points of view. We encourage this change and are ready to offer guidance.
 
 ## Pain Points
 
@@ -41,9 +42,9 @@ The MVC architecture is obsolete. It is yesterday's architecture, fit for monoli
 | Migration is risky or expensive | Apidemia uses a proven, phased migration strategy to reduce risk |
 | Lack of internal development expertise | Apidemia provides end-to-end guidance, refactoring, training and support |
 
-## How Apidemia handles migrations
+## How Apidemia Handles Migrations
 
-Apidemia have created a **complex process** that involves several steps to ensure a **smooth migration**. In a nutshell, the current project functionality must be understood and only then can the move be implemented into the destination platform. Over the long run, the Apidemia team offers support and training.
+Apidemia has created a **complex process** that involves several steps to ensure a **smooth migration**. In a nutshell, the current project functionality must be understood and only then can the move be implemented into the destination platform. Over the long run, the Apidemia team offers support and training.
 
 This is the simplified **task list**:
 
@@ -53,14 +54,6 @@ This is the simplified **task list**:
 - **Unit testing and CI/CD pipeline setup** - a vital step to ensure things function the same way in the destination platform.
 - **Post-migration support and team training** - this step depends on the level of collaboration between the original developers and the Apidemia team, so the more closely they work together, the easier it is to onboard the devs for the long run.
 
-## Additional resources
-
-- [Dotkernel Headless Platform](https://www.dotkernel.com/headless-platform/dotkernel-headless-platform-the-whats-hows-and-whys/)
-- [Shared Core Submodule in Dotkernel Headless Platform](https://www.dotkernel.com/headless-platform/shared-core-submodule-in-dotkernel-headless-platform/)
-- [Understanding Middleware](https://www.dotkernel.com/architecture/understanding-middleware/)
-- [Dotkernel Light](https://www.dotkernel.com/dotkernel/dotkernel-light-starting-with-mezzio-microframework-and-laminas-components/)
-- [Migrate Laminas MVC to Dotkernel](https://www.apidemia.com/services/migrate-laminas-mvc-to-dotkernel/)
-
 ## FAQ
 
 **Q: What is Laminas MVC being replaced by?**
@@ -77,3 +70,11 @@ A: A simplified task list: code audit & migration strategy; partial or full migr
 
 **Q: Who offers this migration guidance?**
 A: Apidemia, who has used Zend Framework, Laminas MVC, and Mezzio for years and can analyze and perform the transfer of a legacy platform to Mezzio, offering faster execution times, increased security, faster development, and long-term reliability.
+
+## Resources
+
+- [Dotkernel Headless Platform](https://www.dotkernel.com/headless-platform/dotkernel-headless-platform-the-whats-hows-and-whys/)
+- [Shared Core Submodule in Dotkernel Headless Platform](https://www.dotkernel.com/headless-platform/shared-core-submodule-in-dotkernel-headless-platform/)
+- [Understanding Middleware](https://www.dotkernel.com/architecture/understanding-middleware/)
+- [Dotkernel Light](https://www.dotkernel.com/dotkernel/dotkernel-light-starting-with-mezzio-microframework-and-laminas-components/)
+- [Migrate Laminas MVC to Dotkernel](https://www.apidemia.com/services/migrate-laminas-mvc-to-dotkernel/)
diff --git a/public/md-articles/design-pattern/naming-pattern-for-psr-15-handlers-in-dotkernel-applications.md b/public/md-articles/design-pattern/naming-pattern-for-psr-15-handlers-in-dotkernel-applications.md
index 8b42191f..1c90737d 100644
--- a/public/md-articles/design-pattern/naming-pattern-for-psr-15-handlers-in-dotkernel-applications.md
+++ b/public/md-articles/design-pattern/naming-pattern-for-psr-15-handlers-in-dotkernel-applications.md
@@ -31,12 +31,12 @@ Naming patterns can be defined for different types of files, since `image` files
 Here is a list of items to consider:
 
 - The file names should be kept as **short** as possible, while retaining relevant items to help outline the file's purpose.
-- **Abreviations** are ok to use, but special characters should be avoided, excepting dash and underscore which are fine, no matter the operating system you use.
+- **Abbreviations** are ok to use, but special characters should be avoided, excepting dash and underscore which are fine, no matter the operating system you use.
 - **Versioning and metadata** can also help visually.
 - Grouping files into **folders** is also recommended, especially when you are dealing with files that are related.
 - If **category names** are relevant to use, you can standardize their names by using a shortened version, maybe with 2-3 letters.
 
-After defining your naming pattern, the most import item by far is to **communicate the pattern to the team**. A top-level README file with the documentation should be kept handy for any developer who creates new files.
+After defining your naming pattern, the most important item by far is to **communicate the pattern to the team**. A top-level README file with the documentation should be kept handy for any developer who creates new files.
 
 ## The naming pattern for Dotkernel Handlers
 
@@ -45,7 +45,7 @@ HTTP request handlers are at the core of any web application. They receive a req
 Even the first paragraph above mentions several elements that are relevant. The naming pattern for our `Handlers` contains:
 
 - The **method** or verb used by the handler (e.g. GET, POST).
-- The **resouce** name (e.g. Admin, Account).
+- The **resource** name (e.g. Admin, Account).
 - The performed **action** (e.g. CreateForm, List).
 - An optional **Form** if the handler returns a form that will perform another action when submitted.
 - The string **Handler**.
@@ -75,8 +75,24 @@ You will likely need to update and delete products further down the line, so you
 
 It takes only a minute to build the proper name for each handler, which takes you and other team members no more than a second to figure out what it does. You will thank yourself in the future.
 
-## Additional resources
+## FAQ
 
-[PSR-15](https://www.php-fig.org/psr/psr-15/)
+**Q: What is a naming pattern?**
+A: A naming pattern helps you organize and quickly identify your files by using relevant strings in file names, such as what a file refers to, the action it performs, how it relates to other files, its author, and its creation date.
 
-[Dotkernel Application Repositories](https://github.com/dotkernel)
+**Q: What elements make up the naming pattern for Dotkernel Handlers?**
+A: The method or verb used by the handler (e.g. GET, POST), the resource name (e.g. Admin, Account), the performed action (e.g. CreateForm, List), an optional Form suffix, and the string Handler.
+
+**Q: What wording is used for the performed actions (CRUD)?**
+A: Create, Get for Read, Edit for Update, and Delete.
+
+**Q: Where is this naming pattern used?**
+A: It is used in Dotkernel Admin v6 and will also be implemented in the next releases for Frontend and Light.
+
+**Q: What is a practical example of this naming pattern?**
+A: For a product resource managed by admin users, you would get handlers such as `GetProductCreateFormHandler`, `PostProductCreateHandler`, `GetProductEditFormHandler`, `PostProductEditHandler`, `PostProductDeleteHandler`, and `GetProductListHandler`.
+
+## Resources
+
+- [PSR-15](https://www.php-fig.org/psr/psr-15/)
+- [Dotkernel Application Repositories](https://github.com/dotkernel)
diff --git a/public/md-articles/dotkernel-api/api-client-migration-from-postman-to-bruno.md b/public/md-articles/dotkernel-api/api-client-migration-from-postman-to-bruno.md
index c19a0604..d4a42910 100644
--- a/public/md-articles/dotkernel-api/api-client-migration-from-postman-to-bruno.md
+++ b/public/md-articles/dotkernel-api/api-client-migration-from-postman-to-bruno.md
@@ -11,111 +11,90 @@ language: "en"
 # API Client Migration: From Postman to Bruno
 
 ## TL;DR
+
 The team has used Postman for years but is considering switching to Bruno, a lightweight, offline-first alternative, reflecting a broader PHP community trend toward local-first, Git-native developer tools.
 Bruno wins on offline access, version control via Git, performance, and (arguably) security, while Postman still offers a broader feature set for larger, budget-having teams.
 
 ## Why We Switched to the Offline-Focused Bruno
 
-Every API developer knows that to build an API properly **you need a reliable client for testing and interacting with the API**. Ideally this tool should be free, it should store endpoint collections and share them easily with your team, and it should be fast and secure.
-
-Over the years we have been using Postman as our go-to API tester, but recently we have considered **shifting to Bruno**, a lightweight alternative. We are not the first to consider this change. There is a **general trend** in the PHP community toward **local-first, Git-native developer tools**.
+Every API developer needs a reliable client for testing and interacting with the API - ideally free, able to store and share endpoint collections easily with a team, fast, and secure.
+Postman has been the team's go-to tool for years, but they are now considering Bruno, part of a general trend in the PHP community toward local-first, Git-native developer tools.
 
 ## Comparing Postman to Bruno
 
-![](/uploads/article/019f8a80-cc8f-729f-99cd-7e0d87163867/bruno-vs-postman1-1024x683.jpg)
-
-### Architecture
-
-Primarily, we use collections to save our API endpoints and then share them among our developers to streamline testing. Postman has recently decided to only allow **one user account in their free plan**. In some cases, it might be enough, but this is one reason why Postman is less reliable right now.
-
-Bruno comes with a different approach: **a fully-offline experience** based on shared `.bru` files. Being that it's offline means that there is **no restriction on the number of developers** using Bruno's files, so it's an advantage for the way we do things.
-
-### Version Control
-
-Postman focuses on storing collections and handling version control in the cloud, **forcing developers to always be online**. You can still export/import collections via their UI.
-
-Bruno's `.bru` **files can be saved in the Git repository** and easily accessed by all members of the dev team. Version control for Bruno files is handled entirely via Git, just like for any other file on your project.
-
-### Feature Scope
-
-A major difference between Postman and Bruno is the feature scope. Where Postman offers a **complete platform for the API lifecycle**, Bruno focuses mainly on **interacting with the API, writing simple tests, and building local collections**.
-
-Postman is the definite winner in this department, if you also use features like mocking, documentation, and CI/CD integration. Given that we use different tool for these additional features, Postman doesn't really benefit us compared to Bruno.
-
-### Performance
-
-Bruno is the clear winner here, given that it **uses much less RAM** and is **generally faster**.
+| Aspect | Postman | Bruno |
+|---|---|---|
+| Architecture | Free plan limited to one user account | Fully-offline experience via shared `.bru` files; no restriction on number of developers |
+| Version control | Handled in the cloud; requires being online (export/import via UI possible) | `.bru` files saved directly in the Git repository, versioned via Git like any other file |
+| Feature scope | Complete platform for the API lifecycle (mocking, documentation, CI/CD integration) | Focused mainly on interacting with the API, writing simple tests, and building local collections |
+| Performance | Needs to regularly sync with the cloud and store advanced features in RAM, which can introduce delays | Uses much less RAM and is generally faster |
+| Security | Offers Single Sign-On (SSO) and Role-Based Access Control (RBAC) | Local files never leave the dev environment, arguably more secure |
+| Collection sharing | Limited sharing for multi-member dev teams | Can share via Git, `.zip` file, or a single `.yaml` file; Git is the preferred option |
 
-Postman needs to regularly synchronize with the cloud and store its advanced features in the RAM, which can introduce delays in some cases.
+### Comparison Conclusion
 
-### Security
+Postman is currently a better fit for larger teams willing to allocate a budget for a more feature-rich platform.
+Bruno stores collections in Git, so everything is offline, which the team considers more secure while also being generally faster.
 
-Postman offers **Single Sign-On (SSO) and Role-Based Access Control (RBAC)**, but we find these not to be useful for our workflow.
+## Alternative API Clients
 
-Bruno's local files do offer a distinct advantage in that these **files never leave your dev environment**. It can be argued that it's **more secure** this way, especially since we try to not share our client's files with any online tool if we can help it.
+Bruno is only one of several alternatives to Postman:
 
-### Working with Bruno Collections
+- Hoppscotch - runs in the browser or as a PWA
+- Insomnia - clear UI and large plugin ecosystem
+- HTTPie - focuses on terminal-based workflows
+- Thunder Client - built into Visual Studio Code
+- Apidog - covers the whole API lifecycle
+- Yaak - minimal and fast desktop client
 
-One of the most important functions that Postman has limited right now is the ability to **share collection with dev team made up of multiple members**. Bruno offers several options, like saving a collection to a Git, to a `.zip` file or a single `.yaml` file. By far the best option is sharing via Git which allows a single or multiple developers to quickly sync between multiple work locations, to track change history, and to easily publish their work for public consumption.
-
-We intend to **create a separate Git repository within each project for the Bruno files** to streamline the sharing process. For each new proejct, we normally allocate multiple developers from the get-to: one for frontend, another for backend. But the teams often grow as the project becomes more complex. Developers may be reallocated, so being able to swiftly onboard a new member to the team is vital.
-
-## Comparison Conclusion
-
-Postman is currently a better fit for larger teams that are willing to allocate a budget for their more feature-rich platform. Bruno stores collections in Git, so everything is offline, and thus as far as we are concerned it's more secure, while also being generally faster.
-
-## Alternative API clients
-
-Bruno is only one of the alternatives to Postman. Let's see some of the other API clients available on the market right now:
-
-- [Hoppscotch](https://hoppscotch.io/) runs in the browser or as a PWA (Progressive Web App that offers a native app-like experience).
-- [Insomnia](https://insomnia.rest/) with its clear UI and large plugin ecosystem.
-- [HTTPie](https://httpie.io/) focuses on terminal-based workflows.
-- [Thunder Client](https://www.thunderclient.com/) which is built into Visual Studio Code.
-- [Apidog](https://apidog.com/) covers the whole API lifecycle.
-- [Yaak](https://yaak.app/) with its minimal and fast desktop client.
-
-As far as we are concerned, any one of them can get the job done. The decision comes down to choosing a simple, reliable tool we can use for the forseeable future.
+Any of them can get the job done; the decision comes down to choosing a simple, reliable tool for the foreseeable future.
 
 ## Bruno for Dotkernel
 
-At the moment, Bruno seems to be the best match for us. It offers similar functionality to Postman, with the added benefits of:
-
-- Allowing us to work completely offline.
-- Saving the enpoint collection to our GitHub accounts.
-
-The similar functionality is to be expected, since it's an API client, first and foremost. The offline feature is perhaps what weighed the most in our decision in favor of Bruno.
+Bruno currently seems like the best match for the team, offering similar functionality to Postman plus the ability to work completely offline and save endpoint collections to their GitHub accounts.
+The offline feature weighed most heavily in the decision.
 
 ### Tool Migration
 
-Most of us have only worked with Postman, so switching to another tool can impact efficiency, at least at first. In general, Tool Migration can have an emotional impact on developers who use a tool, because they have to learn the new tool's ins and outs before getting back to the real work.
-
-Given Bruno's straightforward approach and reasonable learning curve, this should be mitigated easily within our company. In fact, we see the switch as an **expansion of our expertise**. We thus prevent getting tied up to one tool, something similar to vendor lock-in for code.
+Since most of the team has only worked with Postman, switching tools can affect efficiency at first, and tool migration can have an emotional impact as developers relearn a new tool's ins and outs.
+Given Bruno's straightforward approach and reasonable learning curve, the team expects this to be mitigated easily, and views the switch as an expansion of their expertise that avoids getting tied to one tool.
 
 ### How Long Will Bruno Last?
 
-We fully expect Bruno to eventually restrict developers with paid plans, just like Postman did, but we'll cross that bridge when we get to it. Hopefully, we won't have to develop our own API client (fingers crossed). For now, **Bruno becomes our de facto API client** and will encourage our whole team to adopt it as soon as possible.
-
-## Additional Resources
-
-[Bruno homepage](https://www.usebruno.com/)
+The team expects Bruno may eventually restrict developers with paid plans too, just like Postman did, but plans to cross that bridge when they get to it.
+For now, Bruno is becoming their de facto API client, and the whole team is being encouraged to adopt it as soon as possible.
 
 ## FAQ
 
 **Q: Why is the team considering a switch from Postman to Bruno?**
-A: They want a reliable API testing client that is free, stores and shares endpoint collections easily with the team, and is fast and secure. This reflects a broader trend in the PHP community toward local-first, Git-native developer tools.
+A: They want a reliable API testing client that is free, stores and shares endpoint collections easily with the team, and is fast and secure.
+This reflects a broader trend in the PHP community toward local-first, Git-native developer tools.
 
 **Q: What is the main architectural difference between Postman and Bruno?**
-A: Postman's free plan now only allows one user account, while Bruno offers a fully-offline experience based on shared .bru files, so there is no restriction on the number of developers using them.
+A: Postman's free plan now only allows one user account, while Bruno offers a fully-offline experience based on shared `.bru` files, so there is no restriction on the number of developers using them.
 
 **Q: How does version control differ between the two tools?**
-A: Postman stores collections and handles version control in the cloud, forcing developers to stay online (though collections can be exported/imported via its UI). Bruno's .bru files can be saved directly in a Git repository and are version-controlled through Git like any other project file.
+A: Postman stores collections and handles version control in the cloud, forcing developers to stay online (though collections can be exported/imported via its UI).
+Bruno's `.bru` files can be saved directly in a Git repository and are version-controlled through Git like any other project file.
 
 **Q: How does performance compare between Postman and Bruno?**
-A: Bruno is the clear winner on performance: it uses much less RAM and is generally faster. Postman needs to regularly synchronize with the cloud and store its advanced features in RAM, which can introduce delays.
+A: Bruno is the clear winner on performance: it uses much less RAM and is generally faster.
+Postman needs to regularly synchronize with the cloud and store its advanced features in RAM, which can introduce delays.
 
 **Q: Is Bruno more secure than Postman?**
-A: Postman offers Single Sign-On (SSO) and Role-Based Access Control (RBAC), which the team doesn't find useful for its workflow. Bruno's local files never leave the dev environment, which the article argues makes it more secure, especially for avoiding sharing client files with online tools.
+A: Postman offers Single Sign-On (SSO) and Role-Based Access Control (RBAC), which the team doesn't find useful for its workflow.
+Bruno's local files never leave the dev environment, which the article argues makes it more secure, especially for avoiding sharing client files with online tools.
 
 **Q: What's the overall conclusion on Postman versus Bruno?**
-A: Postman is currently a better fit for larger teams willing to allocate a budget for a more feature-rich platform. Bruno stores collections in Git so everything works offline, which the team considers more secure while also being generally faster, and it has become their de facto API client.
+A: Postman is currently a better fit for larger teams willing to allocate a budget for a more feature-rich platform.
+Bruno stores collections in Git so everything works offline, which the team considers more secure while also being generally faster, and it has become their de facto API client.
+
+## Resources
+
+- [Bruno homepage](https://www.usebruno.com/)
+- [Hoppscotch](https://hoppscotch.io/)
+- [Insomnia](https://insomnia.rest/)
+- [HTTPie](https://httpie.io/)
+- [Thunder Client](https://www.thunderclient.com/)
+- [Apidog](https://apidog.com/)
+- [Yaak](https://yaak.app/)
diff --git a/public/md-articles/dotkernel-api/api-endpoint-to-collect-client-errors.md b/public/md-articles/dotkernel-api/api-endpoint-to-collect-client-errors.md
index f747529d..53cc2060 100644
--- a/public/md-articles/dotkernel-api/api-endpoint-to-collect-client-errors.md
+++ b/public/md-articles/dotkernel-api/api-endpoint-to-collect-client-errors.md
@@ -10,25 +10,26 @@ language: "en"
 
 # API Endpoint to Collect Client Errors
 
-## API Endpoint to Collect Client Errors
+When a Frontend (e.g. Angular) sits on top of a Dotkernel API, errors can happen - the API's response may have changed overnight, or a variable may simply be `undefined`.
+Since the Frontend runs on the user's own client, there's little that can be done about it directly, so an endpoint was created to let clients submit the error message when something goes wrong.
 
-Let's say you have a **(Client)** **Frontend** (e.g. Angular) over a [Dotkernel API](https://github.com/dotkernel/api) and there may be cases when there are errors, eighter the API changed it's response(s) over night or just a simple variable being `undefined` for some reason.
+## Usage
 
-Since in our case **Frontend** is running on user client there is so little to do but we've come with an ideea for "writing down" any inconveniences.
+Send a POST request to your Dotkernel API on the route:
 
-We have created an **endpoint** where **Clients** can submit the **error message** when things are going down hill.
-
-A simple **POST** to your **Dotkernel API** on route: `https://api.dotkernel.net/error-report`
+```
+https://api.dotkernel.net/error-report
+```
 
-With body:
+With a body:
 
-```
+```shell
 {
     "message": "My awesome error!!!"
 }
 ```
 
-Note: The error **message** will be stored by default in `/log/error-report-endpoint-log.log`, a separate log for **Client** and the message will be saved with a **timestamp**.
+Note: the error message is stored by default in `/log/error-report-endpoint-log.log`, a separate log for Client, and the message is saved together with a timestamp.
 
 ## FAQ
 
@@ -36,7 +37,11 @@ Note: The error **message** will be stored by default in `/log/error-report-endp
 A: When a Frontend client (e.g. Angular) running on the user's machine hits an error against the Dotkernel API - whether from an overnight API response change or a simple undefined variable - there is little that can be done from the client side, so this endpoint lets clients "write down" the error instead.
 
 **Q: How do I submit an error from the client?**
-A: Send a simple POST request to your Dotkernel API's https://api.dotkernel.net/error-report route, with a body such as { "message": "My awesome error!!!" }.
+A: Send a simple POST request to your Dotkernel API's `https://api.dotkernel.net/error-report` route, with a body such as `{ "message": "My awesome error!!!" }`.
 
 **Q: Where is the submitted error message stored?**
-A: By default, it is stored in a separate log file for Client, /log/error-report-endpoint-log.log, with the message saved alongside a timestamp.
+A: By default, it is stored in a separate log file for Client, `/log/error-report-endpoint-log.log`, with the message saved alongside a timestamp.
+
+## Resources
+
+- [Dotkernel API on GitHub](https://github.com/dotkernel/api)
diff --git a/public/md-articles/dotkernel-api/content-negotiation-in-dotkernel-rest-api.md b/public/md-articles/dotkernel-api/content-negotiation-in-dotkernel-rest-api.md
index 3e6ec9dd..096a05cd 100644
--- a/public/md-articles/dotkernel-api/content-negotiation-in-dotkernel-rest-api.md
+++ b/public/md-articles/dotkernel-api/content-negotiation-in-dotkernel-rest-api.md
@@ -11,103 +11,72 @@ language: "en"
 # Content Negotiation in Dotkernel REST API
 
 ## TL;DR
+
 Content negotiation lets clients and servers agree on the format and language of exchanged data.
 It can be handled server-side or client-side (the latter being more versatile), communicated through HTTP headers or URL patterns, and Dotkernel API implements it out of the box using the `Content-Type` and `Accept` headers.
 
-Content negotiation is an important aspect of RESTful APIs to make it possible for diverse systems to work seamlessly together. It's based on enabling clients and servers to agree on the format and language of data they exchange.
-
-## What is the purpose of Content Negotiation?
-
-RESTful resources can support multiple representations. Each team of developers implements one of more ways (e.g. data formats) to receive requests and return responses on the server side. Efficient communication between client and server can only be guaranteed if the both sides agree on how the exchange takes place. This is especially valid if the request and response support multiple formats. The act of agreeing on a way to represent the exchanged data format is content negotiation.
-
-Content negotiation ensures the following:
-
-- **Support for diverse clients** is useful when the requested representation differs.
-  - e.g. `Accept: application/json` or `Accept: application/xml`.
-- **Data format flexibility** can come into play when a client prefers a smaller response.
-  - e.g. Instead of `Accept: application/json`, use `Accept: application/msgpack` which is a binary serialization, making the response smaller and easier to transfer.
-- **Language localization** will respond with content translated into the client's preferred language
-  - e.g. `Accept-Language: en-US`.
-
-## Who decides the data format?
+## What is the Purpose of Content Negotiation?
 
-There are two sides to the exchange:
+RESTful resources can support multiple representations, and efficient client-server communication depends on both sides agreeing on the exchanged data format - this agreement is content negotiation.
+It ensures:
 
-- The client
-- The server
+- **Support for diverse clients**, e.g. `Accept: application/json` or `Accept: application/xml`.
+- **Data format flexibility**, e.g. using `Accept: application/msgpack` (a binary serialization) instead of JSON for a smaller, easier-to-transfer response.
+- **Language localization**, e.g. `Accept-Language: en-US`, to respond with content translated into the client's preferred language.
 
-Technically, either side can decide on how the data is transferred between the two.
+## Who Decides the Data Format?
 
-For **server-side negotiation** the server must decide based on various factors what the most appropriate format should be. This incurs assumptions that can be erroneous and the server-side implementation can also be more complex. This forces the client to adhere to the rules set up on the server-side.
+Either the client or the server can decide:
 
-For **client-side negotiation** the client lets the server know what format it prefers. This approach is more versatile and thus makes more sense.
+- **Server-side negotiation**: the server decides the format based on various factors.
+This can introduce erroneous assumptions and a more complex server-side implementation, and forces the client to adhere to the server's rules.
+- **Client-side negotiation**: the client tells the server what format it prefers.
+This approach is more versatile and makes more sense.
 
-There are two ways to communicate the data format:
-
-- **HTTP request headers**
-- or **resource URI patterns**.
+There are two ways to communicate the preferred data format: HTTP request headers, or resource URI patterns.
 
 ### HTTP Request Headers
 
-The HTTP request headers `Content-Type` and `Accept` are used to determine the data format that will be sent in the request and the response. There are several types to choose from. Here are some examples:
-
-- text/plain
-- text/html
-- application/json
-- application/zip
-- image/gif
-- image/jpeg
-
-Below is an example of what the keys look like in the content package. Note the `Accept` type
+The `Content-Type` and `Accept` headers determine the data format sent in the request and response.
+Examples of types include `text/plain`, `text/html`, `application/json`, `application/zip`, `image/gif`, and `image/jpeg`.
 
-```
+```shell
 Content-Type: application/json, text/plain
 Accept: application/json
 ```
 
-If the `Accept` header is not present, the server gets to decide the format of the response.
-
-### Content Negotiation using URL Patterns
+If the `Accept` header is not present, the server decides the response format.
 
-Below are a couple of ways to communicate a preferred data format.
+### Content Negotiation Using URL Patterns
 
-Via the extension on the URL:
+A preferred format can also be communicated via the URL extension:
 
-```
+```shell
 https://www.example-api.com/record/47.xml
 https://www.example-api.com/record/47.json
 ```
 
-or via an extra parameter:
+or via an extra query parameter:
 
-```
+```shell
 https://www.example-api.com/record/47?format=xml
 https://www.example-api.com/record/47?format=json
 ```
 
-## Defining preferences via a quality factor
-
-The `Accept` header may hold multiple values with an added value that defines preference or priority.
+## Defining Preferences via a Quality Factor
 
-In this example, the client declares it accpets both json and xml formats, with json being preferred over xml, as defined by the numeric value in `q` which can be between 0 and 1. If the server can only satisfy the xml format, it will respond with that. The final alternative is if the server can't respond with either json, or xml, so it responds with what it can.
+The `Accept` header can hold multiple values with an added quality value (`q`, between 0 and 1) that defines preference or priority:
 
-```
+```shell
 Accept: application/json,application/xml;q=0.9,*/*;q=0.8
 ```
 
-## How does Dotkernel API handle Content Negotiation?
-
-Out of the box, **Dotkernel API** uses **HTTP request headers** `Content-Type` and `Accept` to handle **client-side** content negotiation. It has both `application/json`, `application/hal+json` included. Of course, you can change these as development progresses for your project. There is also support for per-route content negotiation, if you should need it.
+In this example, the client accepts both JSON and XML, with JSON preferred. If the server can only satisfy XML, it responds with that; if it can satisfy neither, it responds with whatever it can.
 
-The configuration is done is its own configuration file. The validation is automatic and several explicit errors are handled, based on what format is supported.
+## How Does Dotkernel API Handle Content Negotiation?
 
-Check out the relevant links below for exact details on the Dotkernel implementation of content negotiation.
-
-## Relevant Links
-
-[Content Negotiation in Dotkernel API](https://docs.dotkernel.org/api-documentation/v5/core-features/content-validation/)
-
-[Content types on iana.org](https://www.iana.org/assignments/media-types/media-types.xhtml)
+Out of the box, Dotkernel API uses the `Content-Type` and `Accept` HTTP request headers to handle client-side content negotiation, supporting both `application/json` and `application/hal+json`.
+These can be changed as development progresses, and per-route content negotiation is also supported. Configuration lives in its own configuration file, validation is automatic, and several explicit errors are handled based on the supported format.
 
 ## FAQ
 
@@ -115,16 +84,26 @@ Check out the relevant links below for exact details on the Dotkernel implementa
 A: It's the act of a client and server agreeing on the format and language of the data they exchange, which is important for RESTful APIs since resources can support multiple representations.
 
 **Q: What does content negotiation ensure?**
-A: It ensures support for diverse clients (e.g. Accept: application/json or Accept: application/xml), data format flexibility for smaller responses (e.g. Accept: application/msgpack, a binary serialization), and language localization via headers like Accept-Language: en-US.
+A: It ensures support for diverse clients (e.g. `Accept: application/json` or `Accept: application/xml`), data format flexibility for smaller responses (e.g. `Accept: application/msgpack`, a binary serialization), and language localization via headers like `Accept-Language: en-US`.
 
 **Q: Who decides the data format, the client or the server?**
-A: Either side technically can. In server-side negotiation, the server decides based on various factors, which can introduce erroneous assumptions and more complex implementation, forcing the client to adhere to server rules. In client-side negotiation, the client tells the server what format it prefers, which is more versatile and makes more sense.
+A: Either side technically can.
+In server-side negotiation, the server decides based on various factors, which can introduce erroneous assumptions and more complex implementation, forcing the client to adhere to server rules.
+In client-side negotiation, the client tells the server what format it prefers, which is more versatile and makes more sense.
 
 **Q: How can the preferred data format be communicated?**
-A: Via HTTP request headers (Content-Type and Accept) or via resource URI patterns, such as a file extension in the URL (e.g. /record/47.json) or an extra query parameter (e.g. /record/47?format=json). If the Accept header is not present, the server decides the response format.
+A: Via HTTP request headers (`Content-Type` and `Accept`) or via resource URI patterns, such as a file extension in the URL (e.g. `/record/47.json`) or an extra query parameter (e.g. `/record/47?format=json`).
+If the `Accept` header is not present, the server decides the response format.
 
 **Q: How does the quality factor (q) work in the Accept header?**
-A: The Accept header can list multiple accepted formats with a q value between 0 and 1 to express preference, e.g. Accept: application/json,application/xml;q=0.9,*/*;q=0.8. The server responds with the most preferred format it can satisfy, falling back further down the list if needed.
+A: The `Accept` header can list multiple accepted formats with a `q` value between 0 and 1 to express preference, e.g. `Accept: application/json,application/xml;q=0.9,*/*;q=0.8`.
+The server responds with the most preferred format it can satisfy, falling back further down the list if needed.
 
 **Q: How does Dotkernel API handle content negotiation?**
-A: Out of the box, Dotkernel API uses the Content-Type and Accept HTTP request headers to handle client-side content negotiation, supporting both application/json and application/hal+json. These can be changed as needed, and per-route content negotiation is also supported.
+A: Out of the box, Dotkernel API uses the `Content-Type` and `Accept` HTTP request headers to handle client-side content negotiation, supporting both `application/json` and `application/hal+json`.
+These can be changed as needed, and per-route content negotiation is also supported.
+
+## Resources
+
+- [Content Negotiation in Dotkernel API](https://docs.dotkernel.org/api-documentation/v5/core-features/content-validation/)
+- [Content types on iana.org](https://www.iana.org/assignments/media-types/media-types.xhtml)
diff --git a/public/md-articles/dotkernel-api/dotkernel-api-1-0-0-released.md b/public/md-articles/dotkernel-api/dotkernel-api-1-0-0-released.md
index 01beaf3b..d660315c 100644
--- a/public/md-articles/dotkernel-api/dotkernel-api-1-0-0-released.md
+++ b/public/md-articles/dotkernel-api/dotkernel-api-1-0-0-released.md
@@ -10,37 +10,31 @@ language: "en"
 
 # Dotkernel API 1.0.0 Released
 
-> Dotkernel API has come a long way since this post was created. [Check out the newest version of Dotkernel API](https://www.dotkernel.com/headless-platform/version-7-adds-postgresql-native-uuid-and-php-8-5/) to stay up to date with the latest functional and security features.
+> Note: Dotkernel API has come a long way since this post was created; a newer version is documented separately.
 
-## [Dotkernel API 1.0.0](https://github.com/dotkernel/api/releases/tag/v1.0.0) was just released!
+Dotkernel API 1.0.0 was just released.
 
- 
+## What is Dotkernel API?
 
-### What is Dotkernel API?
+It is a Zend Expressive 3 application aiming to help developers quickly and efficiently develop an API.
 
-It is a [Zend Expressive 3](https://github.com/zendframework/zend-expressive) application aiming to help developers quickly and efficiently develop an API.
+## How Does It Work?
 
- 
+Under the hood, it uses the following libraries:
 
-### How does it work?
+- `ezimuel/zend-expressive-api` - skeleton application on which this API is based
+- `dotkernel/dot-annotated-services` (^1.1) - for handling dependency injection in your services
+- `dotkernel/dot-console` (^0.1.1) - for developing console applications
+- `dotkernel/dot-errorhandler` (^1.0) - which provides customizable error logging
+- `dotkernel/dot-mail` (^1.0) - for sending emails via SMTP
+- `zendframework/zend-expressive-authentication-oauth2` (^1.0) - for OAuth2 authentication
+- `zendframework/zend-expressive-authorization-rbac` (^1.0) - for role-based permissions
+- `zendframework/zend-expressive-twigrenderer` (^2.4) - for composing email bodies
+- `dasprid/container-interop-doctrine` (^1.1) - database abstraction layer
+- `tuupola/cors-middleware` (^0.9.4) - for automatically sending CORS headers with each request
+- `swagger-api/swagger-ui` (^3.22) - for creating OpenAPI 3 documentation
 
-Under the hood it uses the following libraries:
-
-- [ezimuel/zend-expressive-api](https://github.com/ezimuel/zend-expressive-api): - skeleton application on which this API is based on
-- [dotkernel/dot-annotated-services](https://github.com/dotkernel/dot-annotated-services): ^1.1 - for handling dependency injection in your services
-- [dotkernel/dot-console](https://github.com/dotkernel/dot-console): ^0.1.1 - for developing console applications
-- [dotkernel/dot-errorhandler](https://github.com/dotkernel/dot-errorhandler): ^1.0 - which provides customizable error logging
-- [dotkernel/dot-mail](https://github.com/dotkernel/dot-mail): ^1.0 - for sending emails via SMTP
-- [zendframework/zend-expressive-authentication-oauth2](https://github.com/zendframework/zend-expressive-authentication-oauth2): ^1.0 - for OAuth2 authentication
-- [zendframework/zend-expressive-authorization-rbac](https://github.com/zendframework/zend-expressive-authorization-rbac): ^1.0 - for role-based permissions
-- [zendframework/zend-expressive-twigrenderer](https://github.com/zendframework/zend-expressive-twigrenderer): ^2.4 - for composing email bodies
-- [dasprid/container-interop-doctrine](https://github.com/DASPRiD/container-interop-doctrine): ^1.1 - database abstraction layer
-- [tuupola/cors-middleware](https://github.com/tuupola/cors-middleware): ^0.9.4 - for automatically sending CORS headers with each request
-- [swagger-api/swagger-ui](https://github.com/swagger-api/swagger-ui): ^3.22 - for creating OpenAPI 3 documentation
-
- 
-
-### What does it offer?
+## What Does It Offer?
 
 Out-of-the-box, Dotkernel API provides the following features:
 
@@ -50,15 +44,29 @@ Out-of-the-box, Dotkernel API provides the following features:
 - Members are allowed to manage only their own accounts
 - OpenAPI 3 documentation - also an interactive interface that developers can use to integrate your API
 
- 
-
 ## FAQ
 
 **Q: What is Dotkernel API?**
 A: It is a Zend Expressive 3 application aiming to help developers quickly and efficiently develop an API.
 
 **Q: What key libraries does Dotkernel API 1.0.0 use?**
-A: Among others, it's built on the ezimuel/zend-expressive-api skeleton, and uses dotkernel/dot-annotated-services for dependency injection, dotkernel/dot-console for console applications, dotkernel/dot-errorhandler for error logging, dotkernel/dot-mail for SMTP email, zend-expressive-authentication-oauth2 for OAuth2 authentication, zend-expressive-authorization-rbac for role-based permissions, and swagger-api/swagger-ui for OpenAPI 3 documentation.
+A: Among others, it's built on the `ezimuel/zend-expressive-api` skeleton, and uses `dotkernel/dot-annotated-services` for dependency injection, `dotkernel/dot-console` for console applications, `dotkernel/dot-errorhandler` for error logging, `dotkernel/dot-mail` for SMTP email, `zend-expressive-authentication-oauth2` for OAuth2 authentication, `zend-expressive-authorization-rbac` for role-based permissions, and `swagger-api/swagger-ui` for OpenAPI 3 documentation.
 
 **Q: What features does Dotkernel API 1.0.0 offer out of the box?**
 A: Secure authentication via OAuth2, two user roles (admin and member), where admins can manage any user account and members can manage only their own, plus OpenAPI 3 documentation with an interactive interface developers can use to integrate the API.
+
+## Resources
+
+- [Dotkernel API 1.0.0 release on GitHub](https://github.com/dotkernel/api/releases/tag/v1.0.0)
+- [ezimuel/zend-expressive-api](https://github.com/ezimuel/zend-expressive-api)
+- [dotkernel/dot-annotated-services](https://github.com/dotkernel/dot-annotated-services)
+- [dotkernel/dot-console](https://github.com/dotkernel/dot-console)
+- [dotkernel/dot-errorhandler](https://github.com/dotkernel/dot-errorhandler)
+- [dotkernel/dot-mail](https://github.com/dotkernel/dot-mail)
+- [zendframework/zend-expressive-authentication-oauth2](https://github.com/zendframework/zend-expressive-authentication-oauth2)
+- [zendframework/zend-expressive-authorization-rbac](https://github.com/zendframework/zend-expressive-authorization-rbac)
+- [zendframework/zend-expressive-twigrenderer](https://github.com/zendframework/zend-expressive-twigrenderer)
+- [dasprid/container-interop-doctrine](https://github.com/DASPRiD/container-interop-doctrine)
+- [tuupola/cors-middleware](https://github.com/tuupola/cors-middleware)
+- [swagger-api/swagger-ui](https://github.com/swagger-api/swagger-ui)
+- [Newest version of Dotkernel API](https://www.dotkernel.com/headless-platform/version-7-adds-postgresql-native-uuid-and-php-8-5/)
diff --git a/public/md-articles/dotkernel-api/dotkernel-api-client-side-authorization.md b/public/md-articles/dotkernel-api/dotkernel-api-client-side-authorization.md
index 84ce5982..c041578c 100644
--- a/public/md-articles/dotkernel-api/dotkernel-api-client-side-authorization.md
+++ b/public/md-articles/dotkernel-api/dotkernel-api-client-side-authorization.md
@@ -10,13 +10,13 @@ language: "en"
 
 # Dotkernel API Client Side Authorization
 
-**This article covers the basic authorization of a Client application which use a backend built using** [**Dotkernel API**](https://github.com/dotkernel/api)
+This article covers the basic authorization of a Client application which uses a backend built using Dotkernel API.
 
 ## Authorization Request
 
-Client application users send a **POST** request to the backend containing the following JSON object:
+Client application users send a POST request to the backend containing the following JSON object:
 
-```
+```shell
 {
 "grant_type": "password",
 "client_id": "{API_CLIENT}",
@@ -29,9 +29,9 @@ Client application users send a **POST** request to the backend containing the f
 
 ## Authorization Response
 
-If the credentials are correct, the **API** will return a **JSON** object containing the authentication data:
+If the credentials are correct, the API will return a JSON object containing the authentication data:
 
-```
+```shell
 {
 "token_type": "Bearer",
 "expires_in": 86400,
@@ -40,15 +40,19 @@ If the credentials are correct, the **API** will return a **JSON** object contai
 }
 ```
 
-When sending **API** requests to an endpoint which requires authorization, an *Authorization* header must be present containing the following data: `"Bearer {access_token}"`, where {access_token} represents the content of the key with the same name found in the above response.
+When sending API requests to an endpoint which requires authorization, an `Authorization` header must be present containing `"Bearer {access_token}"`, where `{access_token}` represents the content of the key with the same name found in the authorization response.
 
 ## FAQ
 
 **Q: What does a client send to request authorization?**
-A: The client application sends a POST request to the backend with a JSON object containing grant_type (set to "password"), client_id, client_secret, scope, username/email, and password.
+A: The client application sends a POST request to the backend with a JSON object containing `grant_type` (set to "password"), `client_id`, `client_secret`, `scope`, `username`/email, and `password`.
 
 **Q: What does the API return when authorization succeeds?**
-A: If the credentials are correct, the API returns a JSON object containing token_type ("Bearer"), expires_in (86400 seconds), an access_token, and a refresh_token.
+A: If the credentials are correct, the API returns a JSON object containing `token_type` ("Bearer"), `expires_in` (86400 seconds), an `access_token`, and a `refresh_token`.
 
 **Q: How do I use the access token in subsequent requests?**
-A: When sending API requests to an endpoint that requires authorization, include an Authorization header containing "Bearer {access_token}", where {access_token} is the value returned in the authorization response.
+A: When sending API requests to an endpoint that requires authorization, include an Authorization header containing `"Bearer {access_token}"`, where `{access_token}` is the value returned in the authorization response.
+
+## Resources
+
+- [Dotkernel API on GitHub](https://github.com/dotkernel/api)
diff --git a/public/md-articles/dotkernel-api/dotkernel-api-server-side-authorization.md b/public/md-articles/dotkernel-api/dotkernel-api-server-side-authorization.md
index 79b9015b..5a0fbb31 100644
--- a/public/md-articles/dotkernel-api/dotkernel-api-server-side-authorization.md
+++ b/public/md-articles/dotkernel-api/dotkernel-api-server-side-authorization.md
@@ -11,27 +11,26 @@ language: "en"
 # Dotkernel API Server Side Authorization
 
 ## TL;DR
+
 Dotkernel API endpoints can be protected at three levels: no-auth, authentication, and authorization.
 Access is configured in `config/autoload/authorization.local.php` under the `zend-expressive-authorization-rbac` key, using a `roles` section for role inheritance and a `permissions` section for route access.
 Authentication endpoints require a valid Bearer token and return `401 Unauthorized` if it's missing, while authorization endpoints additionally check role permissions and return `403 Forbidden`.
 
-**This article covers the basic authorization of a Server Side application  built using [Dotkernel API](https://github.com/dotkernel/api)**
-
-## Protecting an endpoint
+This article covers the basic authorization of a Server Side application built using [Dotkernel API](https://github.com/dotkernel/api).
 
-- **no-auth:** the resource can be accessed without the need of authentication/authorization
-- **authentication**: the resource can be accessed only by authenticated users
-- **authorization:** the resource can be accessed only by authenticated AND authorized users
+## Protecting an Endpoint
 
-Configuring access to the endpoints is done by editing the following config file:
+- no-auth: the resource can be accessed without the need of authentication/authorization
+- authentication: the resource can be accessed only by authenticated users
+- authorization: the resource can be accessed only by authenticated AND authorized users
 
-`config/autoload/authorization.local.php`
+Configuring access to the endpoints is done by editing the following config file: `config/autoload/authorization.local.php`.
 
-> **NOTE** If this file is missing from your application, locate it's dist file: `config/autoload/authorization.local.php.dist` and copy-paste it as the above-mentioned `config/autoload/authorization.local.php`
+> Note: If this file is missing from your application, locate its dist file `config/autoload/authorization.local.php.dist` and copy it as the above-mentioned `config/autoload/authorization.local.php`.
 
-You should look for the array inside this config key: `zend-expressive-authorization-rbac`
+You should look for the array inside this config key: `zend-expressive-authorization-rbac`.
 
-```
+```php
 'zend-expressive-authorization-rbac' => ,
         'member' => ,
         'guest'  => ,
@@ -41,37 +40,45 @@ You should look for the array inside this config key: `zend-expressive-authoriza
 ]
 ```
 
-Under the key **roles** you can define role inheritance. In the above example
+Under the key roles you can define role inheritance.
+In the above example:
 
-- **admin** inherits from no other role 'admin' => []
-- **member** inherits from admin 'member' =>
-- **guest** inherits from member 'guest' =>
+- admin inherits from no other role: `'admin' => []`
+- member inherits from admin: `'member' =>`
+- guest inherits from member: `'guest' =>`
 
-***Of course, this setup is just a model, you should not use it in live projects because guests will end up having the same rights as admins.***
+Of course, this setup is just a model, you should not use it in live projects because guests will end up having the same rights as admins.
 
-Under the key **permissions** you can define which routes are accessible to a role. In the above example, a **member** has access to the routes named **avatar**, **users** and **user**.
+Under the key permissions you can define which routes are accessible to a role.
+In the above example, a member has access to the routes named avatar, users and user.
 
-### 1. No-auth endpoints:
+### 1. No-Auth Endpoints
 
-These endpoints can be accessed without authentication/authorization. Examples could be: *login*, *register*, *contact* etc... Creating a route for such an endpoint will use only the handler(s) responsible for returning the content:
+These endpoints can be accessed without authentication/authorization.
+Examples could be: login, register, contact etc.
+Creating a route for such an endpoint will use only the handler(s) responsible for returning the content:
 
-```
+```php
 $app->get('/users', UserHandler::class, 'users');
 ```
 
-### 2. Endpoints requiring Authentication:
+### 2. Endpoints Requiring Authentication
 
-These endpoints can be accessed only if a valid `Bearer token` is present in the request headers. Else, the API will return a `**401 Unauthorized**` response. Creating a route for such an endpoint will have a structure similar to the following example:
+These endpoints can be accessed only if a valid `Bearer token` is present in the request headers.
+Else, the API will return a `401 Unauthorized` response.
+Creating a route for such an endpoint will have a structure similar to the following example:
 
-```
+```php
 $app->get('/users', , 'users');
 ```
 
-### 3. Endpoints requiring Authorization:
+### 3. Endpoints Requiring Authorization
 
-These endpoints can be accessed only if a valid `Bearer token` is present in the request headers. Else, the API will return a `**403 Forbidden**` response. Creating a route for such an endpoint will have a structure similar to the following example:
+These endpoints can be accessed only if a valid `Bearer token` is present in the request headers.
+Else, the API will return a `403 Forbidden` response.
+Creating a route for such an endpoint will have a structure similar to the following example:
 
-```
+```php
 $app->get('/users', , 'users');
 ```
 
@@ -81,13 +88,17 @@ $app->get('/users', , 'users');
 A: no-auth, where the resource can be accessed without authentication/authorization; authentication, where only authenticated users can access the resource; and authorization, where only authenticated AND authorized users can access it.
 
 **Q: Where do I configure access to the endpoints?**
-A: In config/autoload/authorization.local.php. If that file is missing from your application, locate its dist file config/autoload/authorization.local.php.dist and copy it as config/autoload/authorization.local.php, then look for the array under the zend-expressive-authorization-rbac config key.
+A: In `config/autoload/authorization.local.php`.
+If that file is missing from your application, locate its dist file `config/autoload/authorization.local.php.dist` and copy it as `config/autoload/authorization.local.php`, then look for the array under the `zend-expressive-authorization-rbac` config key.
 
 **Q: How does role inheritance work under the roles key?**
-A: In the article's example, admin inherits from no other role, member inherits from admin, and guest inherits from member. The article warns this exact setup is just a model and should not be used in live projects, because guests would end up having the same rights as admins.
+A: In the article's example, admin inherits from no other role, member inherits from admin, and guest inherits from member.
+The article warns this exact setup is just a model and should not be used in live projects, because guests would end up having the same rights as admins.
 
 **Q: How do I control which routes a role can access?**
-A: Under the permissions key you define which routes are accessible to a role. In the article's example, a member has access to the routes named avatar, users, and user.
+A: Under the `permissions` key you define which routes are accessible to a role.
+In the article's example, a member has access to the routes named avatar, users, and user.
 
 **Q: What response codes are returned for authentication and authorization endpoints?**
-A: Endpoints requiring authentication return a 401 Unauthorized response if a valid Bearer token isn't present in the request headers. Endpoints requiring authorization return a 403 Forbidden response instead under the same condition.
+A: Endpoints requiring authentication return a 401 Unauthorized response if a valid Bearer token isn't present in the request headers.
+Endpoints requiring authorization return a 403 Forbidden response instead under the same condition.
diff --git a/public/md-articles/dotkernel-api/dotkernel-api-versus-laminas-api-tools.md b/public/md-articles/dotkernel-api/dotkernel-api-versus-laminas-api-tools.md
index ea15aa0e..fec262c0 100644
--- a/public/md-articles/dotkernel-api/dotkernel-api-versus-laminas-api-tools.md
+++ b/public/md-articles/dotkernel-api/dotkernel-api-versus-laminas-api-tools.md
@@ -11,12 +11,14 @@ language: "en"
 # Dotkernel API versus Laminas API Tools
 
 ## TL;DR
+
 This article compares the basic features of Laminas API Tools and Dotkernel API side by side, covering architecture, versioning, documentation, authentication, and more.
 It highlights that Dotkernel API is a solid alternative now that Laminas API Tools has been archived, since Dotkernel API uses a modern middleware architecture, MIT license, and evolution-based deprecations instead of traditional versioning.
 
-Below we have created an analysis of the basic features available in **Laminas Api Tools** and **Dotkernel API**. It's intended to highlight the differences between the two and also to showcase why Dotkernel API is a good alternative for Laminas API Tools, especially considering the latter's archived status.
+Below we have created an analysis of the basic features available in **Laminas API Tools** and **Dotkernel API**.
+It's intended to highlight the differences between the two and also to showcase why Dotkernel API is a good alternative for Laminas API Tools, especially considering the latter's archived status.
 
-> The table below refers to [Dotkernel API V7](https://github.com/dotkernel/api/tree/7.0)
+> The table below refers to [Dotkernel API V7](https://github.com/dotkernel/api/tree/7.0).
 
 |  | **API Tools (formerly Apigility)** | **Dotkernel API** |
 | --- | --- | --- |
@@ -40,4 +42,24 @@ Below we have created an analysis of the basic features available in **Laminas A
 
 ## Note
 
-> - Versioning is replaced by [Deprecations](https://docs.dotkernel.org/api-documentation/v6/tutorials/api-evolution/), using evolution strategy
+- Versioning is replaced by [Deprecations](https://docs.dotkernel.org/api-documentation/v6/tutorials/api-evolution/), using an evolution strategy.
+
+## FAQ
+
+**Q: What is the purpose of this comparison?**
+A: It highlights the differences between Laminas API Tools and Dotkernel API, and shows why Dotkernel API is a good alternative now that Laminas API Tools is archived.
+
+**Q: Which version of Dotkernel API does the comparison table refer to?**
+A: Dotkernel API V7.
+
+**Q: What architecture does each project use?**
+A: Laminas API Tools uses an MVC, event-driven architecture, while Dotkernel API uses a middleware architecture.
+
+**Q: What license does each project use?**
+A: Laminas API Tools is licensed under BSD-3, while Dotkernel API is licensed under MIT.
+
+**Q: How does Dotkernel API handle API versioning?**
+A: Instead of traditional versioning, Dotkernel API replaces it with Deprecations, using an evolution (API Evolution) strategy.
+
+**Q: What documentation options does each project support?**
+A: Laminas API Tools generates Swagger documentation automatically, while Dotkernel API supports manual Postman documentation as well as automated OpenAPI 3.0 (Swagger) documentation.
diff --git a/public/md-articles/dotkernel-api/error-reporting-endpoint-in-dotkernel-api.md b/public/md-articles/dotkernel-api/error-reporting-endpoint-in-dotkernel-api.md
index ead39c7d..c8094dca 100644
--- a/public/md-articles/dotkernel-api/error-reporting-endpoint-in-dotkernel-api.md
+++ b/public/md-articles/dotkernel-api/error-reporting-endpoint-in-dotkernel-api.md
@@ -11,78 +11,89 @@ language: "en"
 # Error reporting endpoint in Dotkernel API
 
 ## TL;DR
+
 Dotkernel API includes an error reporting endpoint that lets frontend developers securely report bugs and incorrect data processing back to the API, even when no fatal error shows up in the logs.
 It works by sending a POST request to `/error-report` with a token in the header; the API validates the request against configured tokens, domains, and IPs before logging the message.
 Setup involves generating a token, adding it to `config/autoload/error-handling.global.php`, and having the frontend send the `Error-Reporting-Token` and `Origin` headers.
 
-Dotkernel API has received a lot of love from our developers, with regular updates to the platform for years. We use Dotkernel API in our projects, so any bugs and issues are addressed as soon as they are found. Still, it's not unlikely that some hidden issues remain in fringe use cases that we simply haven't explored. The occurrence of bugs increases when the API is used in a complex frontend project.
+Dotkernel API has received a lot of love from our developers, with regular updates to the platform for years.
+We use Dotkernel API in our projects, so any bugs and issues are addressed as soon as they are found.
+Still, it's not unlikely that some hidden issues remain in fringe use cases that we simply haven't explored.
+The occurrence of bugs increases when the API is used in a complex frontend project.
 
-Fatal errors are easily found in the API logs, but it's another matter altogether to deal with incorrect data processing that doesn't generate errors in the frontend that interfaces with the API. The error reporting endpoint was designed to allow the **frontend developers** of your API to report any bugs they encounter in a secure way that is fully under your control.
+Fatal errors are easily found in the API logs, but it's another matter altogether to deal with incorrect data processing that doesn't generate errors in the frontend that interfaces with the API.
+The error reporting endpoint was designed to allow the frontend developers of your API to report any bugs they encounter in a secure way that is fully under your control.
 
-## Example case usage
+## Example Case Usage
 
 - Frontend developed in Angular.
-- Frontend developer will use try-catch in the code in order to send **frontend errors** back to the API.
+- Frontend developer will use try-catch in the code in order to send frontend errors back to the API.
 
-## How to use it on the API side
+## How to Use It on the API Side
 
-Error reporting is done by sending a **POST** request to the `/error-report` endpoint, together with a **token** in the header. In the sections below we will detail how to configure error reporting in your API and how the endpoint is used by the frontend developers.
+Error reporting is done by sending a POST request to the `/error-report` endpoint, together with a token in the header.
+In the sections below we will detail how to configure error reporting in your API and how the endpoint is used by the frontend developers.
 
-### Generating a token and adding it to your API config
+### Generating a Token and Adding It to Your API Config
 
-First you need to generate a token for your request. This is done by using the below command.
+First you need to generate a token for your request.
+This is done by using the below command.
 
-```
+```bash
 php ./bin/cli.php token:generate error-reporting
 ```
 
 The resulting token has this format `0123456789abcdef0123456789abcdef01234567`.
-**Note:** this example is provided just to let you know what to look for.
+Note: this example is provided just to let you know what to look for.
 
-Copy the generated token in your `config/autoload/error-handling.global.php` file. It should look similar to the example below. Your API can have multiple tokens, if needed.
+Copy the generated token in your `config/autoload/error-handling.global.php` file.
+It should look similar to the example below.
+Your API can have multiple tokens, if needed.
 
-```
+```php
 return ,
         ...
     ]
 ]
 ```
 
-### Validation mechanism
+### Validation Mechanism
 
-Behind the scenes, the API validates your configuration and lets you know if any config items prevent the submission of the error report. Below are the requirements for an application to be able to send error messages to Dotkernel API.
+Behind the scenes, the API validates your configuration and lets you know if any config items prevent the submission of the error report.
+Below are the requirements for an application to be able to send error messages to Dotkernel API.
 
-- **Server-side requirements** stored in `config/autoload/error-handling.global.php` (these can be set/overwritten in `config/autoload/local.php`):
+- Server-side requirements stored in `config/autoload/error-handling.global.php` (these can be set/overwritten in `config/autoload/local.php`):
   - All keys (`enabled`, `path`, `tokens`, `domain_whitelist` and `ip_whitelist`) must exist under `ErrorReportServiceInterface::class`.
   - The error reporting feature must be enabled by setting `ErrorReportServiceInterface::class` . `enabled` to `true`.
   - `ErrorReportServiceInterface::class` . `path` must have a value; if the destination file does not exist, it will be created automatically.
   - `ErrorReportServiceInterface::class` . `tokens` must contain at least one token.
   - At least one of `ErrorReportServiceInterface::class` . `domain_whitelist`/`ip_whitelist` must have at least one value.
 
-**Note:** In `src/App/src/Service/ErrorReportService.php`, the method `checkRequest()` tries to validate the request by checking matches for `domain_whitelist` with `isMatchingDomain()` and for `ip_whitelist` with `isMatchingIpAddress()`.
+Note: In `src/App/src/Service/ErrorReportService.php`, the method `checkRequest()` tries to validate the request by checking matches for `domain_whitelist` with `isMatchingDomain()` and for `ip_whitelist` with `isMatchingIpAddress()`.
 If both return `false`, a `ForbiddenException` is thrown and the error message does not get stored.
 
-- **Application-side requirements**:
+- Application-side requirements:
   - Send the `Error-Reporting-Token` header with a valid token previously stored in `config/autoload/error-handling.global.php` in the `ErrorReportServiceInterface::class` . `tokens` array.
   - Send the `Origin` header set to the application's URL; this is the application that sends the error message.
 
-**Note:**
+Note:
 
 - The tokens under `ErrorReportServiceInterface::class` . `tokens` do not expire.
 - The log file stores the token value too, making it easy to identify which application sent the error message.
 
 If your request passes all the checks, the message is saved in the log file specified in `ErrorReportServiceInterface::class` . `path`.
 
-### Tips and tricks
+### Tips and Tricks
 
-If there are multiple applications that report errors to your API, you can **assign a different error reporting token** for each. The tokens support key-value pairs where:
+If there are multiple applications that report errors to your API, you can assign a different error reporting token for each.
+The tokens support key-value pairs where:
 
-- The **key** is an alias relevant to the assigned application that uses it.
-- The **value** is the token itself.
+- The key is an alias relevant to the assigned application that uses it.
+- The value is the token itself.
 
 Example:
 
-```
+```php
 // ...
 return ,
     ],
@@ -93,13 +104,15 @@ The log file will have entries similar to the below:
 
 > Demo error message
 
-The inclusion of the token helps you identify the source of the error message. In our example, it's the application that uses the `0123456789abcdef0123456789abcdef01234567` token, which is assigned to the application `frontend`.
+The inclusion of the token helps you identify the source of the error message.
+In our example, it's the application that uses the `0123456789abcdef0123456789abcdef01234567` token, which is assigned to the application `frontend`.
 
-## How to use it on the Frontend side (Angular example)
+## How to Use It on the Frontend Side (Angular Example)
 
-The API developer sends a generated token to the frontend developer who will save it in their `environment.staging.ts` and/or `environment.prod.ts`. From then on, it's the frontend developer's job to set up an error reporting function similar to the one below.
+The API developer sends a generated token to the frontend developer who will save it in their `environment.staging.ts` and/or `environment.prod.ts`.
+From then on, it's the frontend developer's job to set up an error reporting function similar to the one below.
 
-```
+```typescript
 postError(body: object): Promise<any> {
      return new Promise((resolve, reject) => {
       return this.http.post(API_ENDPOINT + 'error-report', body , {headers: new HttpHeaders({'Error-Reporting-Token': 'TOKEN', 'Origin': 'https://example.com'})})).subscribe({
@@ -115,12 +128,33 @@ postError(body: object): Promise<any> {
 
 Whenever an error is found, the frontend will call `postError()` with a relevant description under `message`.
 
-```
+```typescript
 apiService.postError({message: 'ERROR MESSAGE'})
 ```
 
 ## Conclusion
 
-The error reporting feature in Dotkernel API is a secured and highly configurable tool for users of your API to report any unwanted behavior. More often than not, a detailed error report will help developers understand how to replicate the issue and fix it in due course.
+The error reporting feature in Dotkernel API is a secured and highly configurable tool for users of your API to report any unwanted behavior.
+More often than not, a detailed error report will help developers understand how to replicate the issue and fix it in due course.
 
 This article is also included in the full API documentation [https://docs.dotkernel.org/api-documentation/v5/core-features/error-reporting](https://docs.dotkernel.org/api-documentation/v5/core-features/error-reporting).
+
+## FAQ
+
+**Q: What is the error reporting endpoint for?**
+A: It lets frontend developers of an API report bugs and incorrect data processing back to the API in a secure, controlled way, which is especially useful for issues that don't show up as fatal errors in the API logs.
+
+**Q: How do you generate a token for error reporting?**
+A: Run `php ./bin/cli.php token:generate error-reporting`, then copy the resulting token into `config/autoload/error-handling.global.php`.
+
+**Q: What server-side requirements must be met for error reporting to work?**
+A: All required keys (`enabled`, `path`, `tokens`, `domain_whitelist`, `ip_whitelist`) must exist under `ErrorReportServiceInterface::class`, the feature must be enabled, `path` must have a value, `tokens` must contain at least one token, and at least one of `domain_whitelist`/`ip_whitelist` must have a value.
+
+**Q: What headers must the frontend application send?**
+A: The `Error-Reporting-Token` header with a valid stored token, and the `Origin` header set to the application's URL.
+
+**Q: What happens if a request fails validation?**
+A: The `checkRequest()` method checks the domain against `domain_whitelist` and the IP against `ip_whitelist`; if both checks fail, a `ForbiddenException` is thrown and the error message is not stored.
+
+**Q: How is the error reporting endpoint called?**
+A: By sending a POST request to the `/error-report` endpoint along with a valid token in the header.
diff --git a/public/md-articles/dotkernel-api/how-to-implement-mailchimp-in-dotkernel-api.md b/public/md-articles/dotkernel-api/how-to-implement-mailchimp-in-dotkernel-api.md
index ac9ffe50..983e168a 100644
--- a/public/md-articles/dotkernel-api/how-to-implement-mailchimp-in-dotkernel-api.md
+++ b/public/md-articles/dotkernel-api/how-to-implement-mailchimp-in-dotkernel-api.md
@@ -11,20 +11,21 @@ language: "en"
 # How to implement MailChimp in Dotkernel API
 
 ## TL;DR
+
 This is a step-by-step guide to adding MailChimp support to a Dotkernel API instance using the `drewm/mailchimp-api` library.
 It covers installing the library, creating a MailChimp config file, building a factory that returns a `DrewM\MailChimp\MailChimp` instance, and registering that factory in `ConfigProvider.php` so it can be injected wherever needed.
 
-## This article will walk you through the process of implementing MailChimp into your instance of [Dotkernel API](https://github.com/dotkernel/api) using [drewm/mailchimp-api](https://github.com/drewm/mailchimp-api)
-
- 
+This article will walk you through the process of implementing MailChimp into your instance of [Dotkernel API](https://github.com/dotkernel/api) using [drewm/mailchimp-api](https://github.com/drewm/mailchimp-api).
 
-**Step 1**: Add the library to your application using the following command: `composer require drewm/mailchimp-api`
+Step 1: Add the library to your application using the following command:
 
- 
+```bash
+composer require drewm/mailchimp-api
+```
 
-**Step 2**: Create configuration file **config/autoload/mailchimp.global.php** and paste the following content inside of it:
+Step 2: Create configuration file `config/autoload/mailchimp.global.php` and paste the following content inside of it:
 
-```
+```php
 <?php
 
 declare(strict_types=1);
@@ -33,11 +34,10 @@ return
 ];
 ```
 
- 
-
-**Step 3**: Create factory **src/App/src/MailChimp/Factory/MailChimpFactory.php** which will return an instance of **DrewM\MailChimp**. Paste the following content inside this file:
+Step 3: Create factory `src/App/src/MailChimp/Factory/MailChimpFactory.php` which will return an instance of `DrewM\MailChimp`.
+Paste the following content inside this file:
 
-```
+```php
 <?php
 
 declare(strict_types=1);
@@ -67,24 +67,23 @@ class MailChimpFactory
 }
 ```
 
- 
-
-**Step 4**: Let your application use this factory by adding it to the main ConfigProvider: To do this, open file **src/App/src/ConfigProvider.php** and locate the method called **getDependencies()**. Inside this method, locate the key **factories** which points to an array. Inside this array add the following line:
+Step 4: Let your application use this factory by adding it to the main ConfigProvider.
+To do this, open file `src/App/src/ConfigProvider.php` and locate the method called `getDependencies()`.
+Inside this method, locate the key `factories` which points to an array.
+Inside this array add the following line:
 
-```
+```php
 MailChimp::class => MailChimpFactory::class,
 ```
 
-Make sure you you add the corresponding **use**s:
+Make sure you add the corresponding uses:
 
-```
+```php
 use Api\App\MailChimp\Factory\MailChimpFactory;
 use DrewM\MailChimp\MailChimp;
 ```
 
- 
-
-After this, you can start using the library by **@Inject**ing **MailChimp::class** where it's needed.
+After this, you can start using the library by @Injecting `MailChimp::class` where it's needed.
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel-api/openapi-implementation-in-dotkernel-api.md b/public/md-articles/dotkernel-api/openapi-implementation-in-dotkernel-api.md
index 3ee396fb..f9de90dd 100644
--- a/public/md-articles/dotkernel-api/openapi-implementation-in-dotkernel-api.md
+++ b/public/md-articles/dotkernel-api/openapi-implementation-in-dotkernel-api.md
@@ -11,82 +11,113 @@ language: "en"
 # OpenAPI implementation in Dotkernel API
 
 ## TL;DR
+
 OpenAPI is a specification for describing an API's structure in a language-agnostic, machine-readable way, offering benefits like standardization, automatic documentation, upfront design, and better collaboration compared to a tool like Postman.
 Dotkernel API has full OpenAPI support: each module (Admin, App, User) documents its endpoints in an `OpenAPI.php` file, which `zircote/swagger-php` turns into documentation rendered via Swagger UI or Redoc.
 Testing protected endpoints in Swagger UI requires generating an authentication token that matches the endpoint's required privileges.
 
-## What is OpenAPI?
+## What Is OpenAPI?
 
-The **OpenAPI Specification** provides a consistent way to develop and interact with an API. It **defines API structure and syntax** in a universal way, regardless of the programming language used in the API's development. API specifications typically use **YAML** or **JSON** to share and use the specification. They allow users of the API to quickly discover how it works by describing its elements, e.g. endpoints, request and response formats, security mechanisms and more.
+The OpenAPI Specification provides a consistent way to develop and interact with an API.
+It defines API structure and syntax in a universal way, regardless of the programming language used in the API's development.
+API specifications typically use YAML or JSON to share and use the specification.
+They allow users of the API to quickly discover how it works by describing its elements, e.g. endpoints, request and response formats, security mechanisms and more.
 
 While not mutually exclusive, OpenAPI has several benefits over Postman:
 
-- **API standardization**: This offers a standard way to describe and document endpoints, request/response models, and other details of your API that enforces design best practices. Postman has no focus on this topic.
-- **Automatic generation of API documentation**: Create comprehensive, machine-readable documentation that helps developers understand how to interact with your API. Postman is not designed to explain the API's components.
-- **API design and development**: Define your API specification, most commonly using YAML and JSON formats, before starting development. Postman is used only to test an existing, completed endpoint.
-- **Improved collaboration**: This benefits frontend and backend developers, as well as operations teams. Postman's free tier is aimed more towards individual or small team development.
-- **API gateways and management**: A wide range of tools and platforms that support OpenAPI allow more streamlined monitoring and management of APIs. Postman has environment management, but primarily on the developer's machine.
+- API standardization: this offers a standard way to describe and document endpoints, request/response models, and other details of your API that enforces design best practices.
+Postman has no focus on this topic.
+- Automatic generation of API documentation: create comprehensive, machine-readable documentation that helps developers understand how to interact with your API.
+Postman is not designed to explain the API's components.
+- API design and development: define your API specification, most commonly using YAML and JSON formats, before starting development.
+Postman is used only to test an existing, completed endpoint.
+- Improved collaboration: this benefits frontend and backend developers, as well as operations teams.
+Postman's free tier is aimed more towards individual or small team development.
+- API gateways and management: a wide range of tools and platforms that support OpenAPI allow more streamlined monitoring and management of APIs.
+Postman has environment management, but primarily on the developer's machine.
 
 Other benefits from using OpenAPI:
 
-- **Code generation**: Automatically generate client code, server stubs, API documentation and even test cases to ensure consistency between the API documentation and implementation.
-- **Interoperability**: Standardization using OpenAPI ensures that the API can interface with other systems.
-- **Testing and validation**: The specification can generate tests to catch bugs early on and ensure correct functionality.
-- **Versioning and change management**: Keeps track of changes and ensures backward compatibility.
+- Code generation: automatically generate client code, server stubs, API documentation and even test cases to ensure consistency between the API documentation and implementation.
+- Interoperability: standardization using OpenAPI ensures that the API can interface with other systems.
+- Testing and validation: the specification can generate tests to catch bugs early on and ensure correct functionality.
+- Versioning and change management: keeps track of changes and ensures backward compatibility.
 
-## The importance of API documentation
+## The Importance of API Documentation
 
-API documentation, in general, is crucial for several reasons. It serves multiple stakeholders that use the API for development, integration and maintenance.
+API documentation, in general, is crucial for several reasons.
+It serves multiple stakeholders that use the API for development, integration and maintenance.
 
-- **Faster developer onboarding, adoption and integration**: Helps developers understand the API better and reduces the learning curve for adopting and integrating the API into other systems. The API documentation should be publicly available, especially if the API is public. It's even more beneficial if the documentation is integrated with a developer portal.
-- **Better collaboration**: Promotes consistency and reduces misunderstandings between developers and users.
-- **Better API quality and maintenance**: Includes details on how to properly use the API, from its data types and required parameters, to error handling procedures. This helps maintain existing functionality when changes are implemented.
-- **Helps troubleshooting**: It defines the correct functionality that helps developers and maintainers find and fix bugs more effectively.
+- Faster developer onboarding, adoption and integration: helps developers understand the API better and reduces the learning curve for adopting and integrating the API into other systems.
+The API documentation should be publicly available, especially if the API is public.
+It's even more beneficial if the documentation is integrated with a developer portal.
+- Better collaboration: promotes consistency and reduces misunderstandings between developers and users.
+- Better API quality and maintenance: includes details on how to properly use the API, from its data types and required parameters, to error handling procedures.
+This helps maintain existing functionality when changes are implemented.
+- Helps troubleshooting: it defines the correct functionality that helps developers and maintainers find and fix bugs more effectively.
 
 ## OpenAPI in Dotkernel API
 
-**Dotkernel API** has full support for OpenAPI, from describing the endpoints and generating the documentation, to rendering and testing the endpoints.
+Dotkernel API has full support for OpenAPI, from describing the endpoints and generating the documentation, to rendering and testing the endpoints.
 
-Each **module** (Admin, App, User) in Dotkernel API contains a file named **OpenAPI.php**. In this file you must document **all of the endpoints from RoutesDelegator.php**. The entries in OpenAPI.php have several descriptive items, the most important being method, request and response. These are used to generate a documentation file from the command line. The static documentation file is rendered using Swagger UI or Redoc in a user-friendly way. You can read more about this [starting here](https://docs.dotkernel.org/api-documentation/v5/openapi/introduction/) and its subsequent pages.
+Each module (Admin, App, User) in Dotkernel API contains a file named `OpenAPI.php`.
+In this file you must document all of the endpoints from `RoutesDelegator.php`.
+The entries in `OpenAPI.php` have several descriptive items, the most important being method, request and response.
+These are used to generate a documentation file from the command line.
+The static documentation file is rendered using Swagger UI or Redoc in a user-friendly way.
+You can read more about this [starting here](https://docs.dotkernel.org/api-documentation/v5/openapi/introduction/) and its subsequent pages.
 
-### Describing OpenAPI components
+### Describing OpenAPI Components
 
-All OpenAPI components require a handful of components that are universally valid for a given project. These are below:
+All OpenAPI components require a handful of components that are universally valid for a given project.
+These are below:
 
-- **OA\Info** contains basic information on your project, like version and name.
-- **OA\Server** has one or more urls to a target host.
-- **OA\SecurityScheme** describes the protection for the endpoint.
-- **OA\ExternalDocumentation** has a url and description for extended documentation related to an item.
-- **OA\Schema** describes a object (e.g. entity) or collection of objects in your project.
+- OA\Info contains basic information on your project, like version and name.
+- OA\Server has one or more urls to a target host.
+- OA\SecurityScheme describes the protection for the endpoint.
+- OA\ExternalDocumentation has a url and description for extended documentation related to an item.
+- OA\Schema describes a object (e.g. entity) or collection of objects in your project.
 
 Read more details about the above [here](https://docs.dotkernel.org/api-documentation/v5/openapi/initialized-components/).
 
-Once you have your basic components defined, you can begin work on the endpoints. The endpoints already made available in Dotkernel API are documented, so you must do the same for the new endpoints you create in your project. This is done by defining these items:
+Once you have your basic components defined, you can begin work on the endpoints.
+The endpoints already made available in Dotkernel API are documented, so you must do the same for the new endpoints you create in your project.
+This is done by defining these items:
 
-- the **request** object (Get, Post, Patch, Put, Delete)
-- the **path** to the resource
-- the endpoint's **summary** and **description**
-- the query/path **parameters**, if required
-- the **request body**, if required
-- the **security** scheme, if required
-- the **response**
+- the request object (Get, Post, Patch, Put, Delete)
+- the path to the resource
+- the endpoint's summary and description
+- the query/path parameters, if required
+- the request body, if required
+- the security scheme, if required
+- the response
 
-Wherever it's appropriate, schemas should be used to ensure consistency. The optional 'tags' item can be used to group operations together. Read more [here](https://docs.dotkernel.org/api-documentation/v5/openapi/initialized-components/).
+Wherever it's appropriate, schemas should be used to ensure consistency.
+The optional 'tags' item can be used to group operations together.
+Read more [here](https://docs.dotkernel.org/api-documentation/v5/openapi/initialized-components/).
 
-### Generating the documentation
+### Generating the Documentation
 
-The documentation is generated using [zircote/swagger-php](https://github.com/zircote/swagger-php). It uses the descriptions you added in the OpenAPI.php files to build the documentation file. The documentation contents can be **listed in the command line** or **saved to a file** in yaml of json format. You can read more [here](https://docs.dotkernel.org/api-documentation/v5/openapi/generate-documentation/).
+The documentation is generated using [zircote/swagger-php](https://github.com/zircote/swagger-php).
+It uses the descriptions you added in the `OpenAPI.php` files to build the documentation file.
+The documentation contents can be listed in the command line or saved to a file in yaml of json format.
+You can read more [here](https://docs.dotkernel.org/api-documentation/v5/openapi/generate-documentation/).
 
-### Alternatives for rendering the documentation
+### Alternatives for Rendering the Documentation
 
 Once you have the documentation generated, it can be rendered in two ways:
 
-- **Swagger UI** allows you to visualize and interact with the API’s resources without worrying about the implementation logic.
-- **Redoc** lists the documentation in read-only mode, detailing example requests and responses.
+- Swagger UI allows you to visualize and interact with the API's resources without worrying about the implementation logic.
+- Redoc lists the documentation in read-only mode, detailing example requests and responses.
 
-### Handling authentication for Swagger UI
+### Handling Authentication for Swagger UI
 
-Most endpoints for your API should be protected, so to access them you are required to generate an **authentication token** (AuthToken). The token is related to the user type, so make sure to check the **privileges required for the endpoint** you are testing. After you submit the token, you can test the endpoints as an authenticated user. Clicking on the 'Try it out' button will activate the required parameter input fields and the textarea for the request body. The 'Execute' button will send the request and return the response. along with its HTTP status code. You can read more details [here](https://docs.dotkernel.org/api-documentation/v5/openapi/use-documentation/).
+Most endpoints for your API should be protected, so to access them you are required to generate an authentication token (AuthToken).
+The token is related to the user type, so make sure to check the privileges required for the endpoint you are testing.
+After you submit the token, you can test the endpoints as an authenticated user.
+Clicking on the 'Try it out' button will activate the required parameter input fields and the textarea for the request body.
+The 'Execute' button will send the request and return the response, along with its HTTP status code.
+You can read more details [here](https://docs.dotkernel.org/api-documentation/v5/openapi/use-documentation/).
 
 ## FAQ
 
@@ -94,7 +125,8 @@ Most endpoints for your API should be protected, so to access them you are requi
 A: A consistent way to develop and interact with an API. It defines API structure and syntax in a universal way, regardless of the programming language used, typically described in YAML or JSON so users can quickly discover endpoints, request/response formats, security mechanisms and more.
 
 **Q: How does OpenAPI compare to Postman?**
-A: OpenAPI standardizes how endpoints and request/response models are described, automatically generates machine-readable documentation, lets you define the API specification before development starts, and improves collaboration across teams. Postman, by contrast, is used mainly to test an already-completed endpoint and has no real focus on standardized documentation or upfront design.
+A: OpenAPI standardizes how endpoints and request/response models are described, automatically generates machine-readable documentation, lets you define the API specification before development starts, and improves collaboration across teams.
+Postman, by contrast, is used mainly to test an already-completed endpoint and has no real focus on standardized documentation or upfront design.
 
 **Q: Where do you document endpoints in Dotkernel API?**
 A: Each module (Admin, App, User) contains an OpenAPI.php file, where all endpoints from that module's RoutesDelegator.php must be documented, primarily describing the method, request and response.
diff --git a/public/md-articles/dotkernel/adding-a-cors-implementation-to-zend-expressive.md b/public/md-articles/dotkernel/adding-a-cors-implementation-to-zend-expressive.md
index a3d28b76..7a55e4f2 100644
--- a/public/md-articles/dotkernel/adding-a-cors-implementation-to-zend-expressive.md
+++ b/public/md-articles/dotkernel/adding-a-cors-implementation-to-zend-expressive.md
@@ -14,17 +14,15 @@ language: "en"
 When a client-side request is blocked with a "No 'Access-Control-Allow-Origin' header" error, it's because the server isn't sending the header that allows a browser to access its data (most common when fetching JSON to process with JavaScript).
 This guide adds CORS support to a Zend Expressive / Dotkernel3 project using Tuupola's Cors Middleware package.
 
-This article is a guide on how to add a CORS implementation on an existing Dotkernel3 project.
-
 ## The issue
 
-If you're facing this message:
-
-"Access to XMLHttpRequest at 'url' has been blocked by cors policy. No 'Access-Control-Allow-Origin header is present on the requested resource."
+If you're facing the error:
 
-It means the server didn't sent the header that lets you access its data through a local client (eg.: browser).
+> "Access to XMLHttpRequest at 'url' has been blocked by cors policy.
+> No 'Access-Control-Allow-Origin header is present on the requested resource."
 
-This issue is most common when trying to get some data (usually json) that you want to process using JavaScript.
+it means the server didn't send the header that lets you access its data through a local client (e.g. a browser).
+This issue is most common when trying to get data (usually JSON) that you want to process using JavaScript.
 
 The error looks similar to the image below:
 
@@ -32,27 +30,22 @@ The error looks similar to the image below:
 
 ## The solution
 
-A simple implementation would be using [Tuupola's Cors Middleware](https://packagist.org/packages/tuupola/cors-middleware) package.
-
-This article was inspired by: [akrabat.com/implementing-tuupola-cors-in-expressive](https://akrabat.com/implementing-tuupola-cors-in-expressive/)
-
-### Adding the package to your project
+A simple implementation uses [Tuupola's Cors Middleware](https://packagist.org/packages/tuupola/cors-middleware) package.
+(This article was inspired by [akrabat.com/implementing-tuupola-cors-in-expressive](https://akrabat.com/implementing-tuupola-cors-in-expressive/).)
 
-Run the following command in your project:
+### 1. Add the package to your project
 
-```
+```shell
 composer require tuupola/cors-middleware
 ```
 
-At the time writing this article the current package version is: 0.9.4.
-
-Follow the next steps to get your Zend Expressive or Dotkernel3 project **CORS friendly**.
+At the time of writing, the current package version is 0.9.4.
 
-### Create the CORS config file
+### 2. Create the CORS config file
 
-Create a **cors.global.php** file in the config/autoload directory.
+Create a `cors.global.php` file in the `config/autoload` directory:
 
-```
+```php
 return [
     'cors' => [
         "origin" => [],
@@ -66,15 +59,11 @@ return [
 ];
 ```
 
-We'll come back at this file to register the CORS middleware.
-
-### Creating a factory for the middleware
+### 3. Create a factory for the middleware
 
-The factory should look like the one below.
+The factory extracts the config from the `cors` key (or initializes an empty array) and instantiates the Tuupola CORS middleware:
 
-The code below extracts de config from the **cors** key if provided or initializes an empty array and instantiates the **Tuupola CORS middleware**.
-
-```
+```php
 <?php
 
 namespace App\Cors;
@@ -91,11 +80,11 @@ class CorsMiddlewareFactory
 }
 ```
 
-### Registering the CORS middleware
+### 4. Register the CORS middleware
 
-Back at **cors.global.php** we will register the cors middleware so our custom implemented factory will be used to create the middleware. (basic config example below)
+Back in `cors.global.php`, register the middleware so the factory above is used to create it:
 
-```
+```php
 <?php
 
 use App\Cors\CorsMiddlewareFactory;
@@ -118,11 +107,11 @@ return [
 ];
 ```
 
-### Final step: Adding (registering) the CorsMiddleware in the pipeline
+### 5. Add the CorsMiddleware to the pipeline
 
-In this last step we only need to add the CorsMiddleware in config/pipelines.php
+In `config/pipelines.php`:
 
-```
+```php
 // don't forget the use statement
 use Tuupola\Middleware\CorsMiddleware;
 
@@ -133,23 +122,29 @@ return function (Application $app, MiddlewareFactory $factory, ContainerInterfac
 };
 ```
 
-Add the cors middleware **after** the Error handler and **before** the middleware providing the data you want to access to make sure everything runs smoothly.
-
+Add the CORS middleware **after** the Error handler and **before** the middleware providing the data you want to access, to make sure everything runs smoothly.
 This should get your project working with CORS.
 
 ## FAQ
 
 **Q: What causes the "No 'Access-Control-Allow-Origin' header" error?**
-A: It means the server didn't send the header that lets a local client, such as a browser, access its data. This is most common when trying to fetch data (usually JSON) that you want to process using JavaScript.
+A: It means the server didn't send the header that lets a local client, such as a browser, access its data.
+This is most common when trying to fetch data (usually JSON) that you want to process using JavaScript.
 
 **Q: What package does the article use to add CORS support?**
-A: Tuupola's Cors Middleware package, installed by running composer require tuupola/cors-middleware in the project.
+A: Tuupola's Cors Middleware package, installed by running `composer require tuupola/cors-middleware` in the project.
 
 **Q: Where does the CORS configuration live?**
-A: In a cors.global.php file created in the config/autoload directory, containing a "cors" key with settings like origin, methods, headers.allow, headers.expose, credentials, and cache.
+A: In a `cors.global.php` file created in the config/autoload directory, containing a "cors" key with settings like origin, methods, headers.allow, headers.expose, credentials, and cache.
 
 **Q: How is the CorsMiddleware wired into the container?**
-A: A CorsMiddlewareFactory extracts the "cors" config array (or an empty array if it's not provided) and instantiates Tuupola's CorsMiddleware with it. That factory is then registered under the "dependencies" > "factories" section of cors.global.php.
+A: A CorsMiddlewareFactory extracts the "cors" config array (or an empty array if it's not provided) and instantiates Tuupola's CorsMiddleware with it.
+That factory is registered under the "dependencies" > "factories" section of cors.global.php.
 
 **Q: Where should the CORS middleware be added in the pipeline?**
-A: In config/pipelines.php via $app->pipe(CorsMiddleware::class), placed after the Error handler and before the middleware that provides the data you want to access.
+A: In config/pipelines.php via `$app->pipe(CorsMiddleware::class)`, placed after the Error handler and before the middleware that provides the data you want to access.
+
+## Resources
+
+- [Tuupola's Cors Middleware package](https://packagist.org/packages/tuupola/cors-middleware)
+- [Implementing Tuupola CORS in Expressive (inspiration article)](https://akrabat.com/implementing-tuupola-cors-in-expressive/)
diff --git a/public/md-articles/dotkernel/adding-a-second-caching-layer-to-wurfl-in-dotkernel-using-apc.md b/public/md-articles/dotkernel/adding-a-second-caching-layer-to-wurfl-in-dotkernel-using-apc.md
index 52ed89ef..2c148046 100644
--- a/public/md-articles/dotkernel/adding-a-second-caching-layer-to-wurfl-in-dotkernel-using-apc.md
+++ b/public/md-articles/dotkernel/adding-a-second-caching-layer-to-wurfl-in-dotkernel-using-apc.md
@@ -13,23 +13,29 @@ language: "en"
 ## TL;DR
 On a high-traffic project using WURFL, profiling showed WURFL's default filesystem cache was costing up to a few hundred milliseconds per request. Adding a small, custom second cache layer on top of WURFL, built on APC, cut response time by an order of magnitude, down to 20-30ms.
 
-On one of our recent projects that used WURFL, response time was an important factor. Profiling revealed that the greatest chunk of response time (up to a few hundred milliseconds) was taken up by WURFL. We realized that its default filesystem cache was too slow for our needs, especially with a relatively high traffic application.
+## The problem
 
-If you're not familiar with how WURFL's caching works, here's a brief introduction:
+On one recent project that used WURFL, response time was an important factor.
+Profiling revealed that the greatest chunk of response time (up to a few hundred milliseconds) was taken up by WURFL.
+The default filesystem cache turned out to be too slow for a relatively high-traffic application.
+
+## How WURFL's caching works
 
 1. The device data is stored at first in a large, zipped XML file, with one entry for each device.
 2. When first called, WURFL unzips the file and reads each device entry.
-3. It then serializes the data and writes it to the cache, using and MD5 signature for the file name (or key name if the cache is not on the filesystem)
+3. It then serializes the data and writes it to the cache, using an MD5 signature for the file name (or key name if the cache is not on the filesystem).
 4. When a user agent is looked up, its MD5 signature is computed and then searched in the cache.
-5. For a number of reasons, the data in the data file is stored as a tree, each device being a node and inheriting all the properties of the nodes above it. So, **for each look-up, a number of files have to be read and their capabilities merged to get all the capabilities of the requested device.**
+5. Because the data is stored as a tree, with each device inheriting the properties of the nodes above it, **each look-up requires a number of files to be read and their capabilities merged** to get all the capabilities of the requested device.
+
+WURFL also has cache providers for APC and memcache, which were tried, but the results weren't impressive.
 
-WURFL has cache providers for APC and memcache as well, which we've tried, but the results weren't impressive.
+## The solution
 
-We realized that we had the wrong approach, especially for use. The WURFL entry for a device has lots of fields that we didn't use.
+The team realized their approach was wrong for their use case - the WURFL entry for a device has lots of fields that weren't actually used.
 
-Our solution involved adding a **second cache layer**, on top of WURFL's, that only cached the fields we were interested in.  This second cache layer make use of **APC**, storing arrays of data in  **User Cache Entries**.
+The solution was adding a **second cache layer** on top of WURFL's own cache, which only cached the fields that were actually needed. This second layer used **APC**, storing arrays of data in **User Cache Entries**.
 
-This small change (under 10 lines of code), decreased our response time by an **order of magnitude**, to 20-30ms.
+This small change (under 10 lines of code) decreased response time by an **order of magnitude**, down to 20-30ms.
 
 ## FAQ
 
@@ -37,13 +43,16 @@ This small change (under 10 lines of code), decreased our response time by an **
 A: Profiling revealed that WURFL's default filesystem cache was taking up to a few hundred milliseconds of response time, which was too slow for a relatively high-traffic application.
 
 **Q: How does WURFL's caching work by default?**
-A: Device data is stored in a large zipped XML file. On first use, WURFL unzips the file, serializes each device's data, and writes it to cache using an MD5 signature of the user agent as the key. Because devices are stored as a tree inheriting properties from parent nodes, each lookup requires reading and merging several files.
+A: Device data is stored in a large zipped XML file.
+On first use, WURFL unzips the file, serializes each device's data, and writes it to cache using an MD5 signature of the user agent as the key.
+Because devices are stored as a tree inheriting properties from parent nodes, each lookup requires reading and merging several files.
 
 **Q: Did WURFL's built-in APC or memcache cache providers solve the problem?**
 A: No. The team tried WURFL's existing cache providers for APC and memcache, but the results weren't impressive.
 
 **Q: What was the actual solution?**
-A: Adding a second cache layer on top of WURFL's own cache, using APC and storing arrays of only the specific fields they actually needed in User Cache Entries. The change was under 10 lines of code.
+A: Adding a second cache layer on top of WURFL's own cache, using APC and storing arrays of only the specific fields they actually needed in User Cache Entries.
+The change was under 10 lines of code.
 
 **Q: What performance improvement did this bring?**
 A: Response time decreased by an order of magnitude, down to about 20-30ms.
diff --git a/public/md-articles/dotkernel/adding-composer-support-in-your-dotkernel-project.md b/public/md-articles/dotkernel/adding-composer-support-in-your-dotkernel-project.md
index b4682b73..d2c9cbfd 100644
--- a/public/md-articles/dotkernel/adding-composer-support-in-your-dotkernel-project.md
+++ b/public/md-articles/dotkernel/adding-composer-support-in-your-dotkernel-project.md
@@ -14,113 +14,98 @@ language: "en"
 Composer is an application-level package manager that auto-loads dependencies (and custom classes) on demand.
 This article covers the steps needed to add a composer.json file to a Dotkernel project, run `composer update`, and safely require the generated autoloader so the project works whether or not Composer is present.
 
-Composer is an application-level package manager. Composer auto-loads the dependencies on demand and can also auto-load custom classes .
-
-This article will cover the needed steps to add composer support to your Dotkernel project or even "composify" it.
-
-Assuming that you know how to use composer (if not you should consider reading [this article](https://www.codementor.io/php/tutorial/composer-install-php-dependency-manager)) we wil move on to your Dotkernel project "composification".
-
- 
-
 ## First things first
 
-The Dotkernel project must have a **composer.json** file so that composer can work.
-
-Our **composer.json** file should look like this:
+The Dotkernel project must have a **composer.json** file so that Composer can work.
+It should look like this:
 
-```
+```json
 {
-  "require" : {
-    "zendframework/zendframework1" : "1.12.*",
-    "mobiledetect/mobiledetectlib" : "2.8.*"
-  },
-  "require-dev" : {
-    "php" : ">=5.4.0"
-  },
+  "require" : {
+    "zendframework/zendframework1" : "1.12.*",
+    "mobiledetect/mobiledetectlib" : "2.8.*"
+  },
+  "require-dev" : {
+    "php" : ">=5.4.0"
+  }
 }
 ```
 
-Note that **zend/zendframework1** may not be necessarily if you already have ZendServer running or the Zend Framework folder within **/usr/share/.**
+Note: `zendframework/zendframework1` may not be necessary if you already have ZendServer running or the Zend Framework folder within `/usr/share/`.
 
-The file above makes sure:
+This file makes sure:
 
 - Zend Framework is present and at version > 1.12.*
 - MobileDetect is present and at version > 2.8
-- The PHP executable is at least at version > 5.4.0 (**only for development, because it is not present in the main require**)
+- The PHP executable is at least at version > 5.4.0 (only for development, because it is not present in the main `require`)
 
- 
+The dependencies provided in the `require` section are also loaded for development purposes if not provided in `require-dev`.
 
-The dependencies provided in the **require** section are also loaded for development purpose if not provided in **require-dev**.
+In order to have these components installed, run the following command in your Dotkernel root path:
 
- 
-
-In order to have these components instaled you must run the following command in your Dotkernel root path
-
-```
+```shell
 composer update
 ```
 
-If the *vendor* folder is present composer will check for updates, and update the packages as needed.
-
-If the *vendor* folder does not exist composer will create a vendor folder. This folder will contain all the requested packages.
-
-Composer will create an autoload file, which will be use to load our dependencies/packages.
-
- 
+If the `vendor` folder is present, Composer will check for updates and update the packages as needed. If the `vendor` folder does not exist, Composer will create it, containing all the requested packages, along with an autoload file used to load the dependencies/packages.
 
 ## Adding Composer Support to Dotkernel
 
-The autoload file created by composer will be used to load our packages.
+The autoload file created by Composer is used to load the packages:
 
-```
+```php
 $composerAutoLoaderPath = realpath(APPLICATION_PATH.'/vendor/autoload.php');
 require_once($composerAutoLoaderPath);
 ```
 
-So far so good, but what if the file does not exist or composer is not present?
-
-First we must make sure the composer autoload path exists and only load the dependencies if composer autoload file was found.
+But what if the file does not exist, or Composer is not present?
+First make sure the Composer autoload path exists, and only load the dependencies if the autoload file was found:
 
-```
+```php
 $composerAutoLoaderPath = realpath('./vendor/autoload.php');
 
 $composerEnabled = file_exists($composerAutoLoaderPath);
 
-if($composerEnabled == true)
-{
-    require_once($composerAutoLoaderPath);
-}
-else
-{
+if ($composerEnabled == true) {
+    require_once($composerAutoLoaderPath);
+} else {
     // handle the error gracefully
-   // or load fallbacks - if exist
+    // or load fallbacks - if exist
 }
 ```
 
-The variable **$composerEnabled** will be true only if the composer path exists so the application behavior can be controlled if composer is not present.
+The variable `$composerEnabled` will be true only if the Composer path exists, so the application behavior can be controlled if Composer is not present.
 
 Later on, the packages can be used like this:
 
-```
+```php
 use VendorName\PackageName\ClassName as MyDependency;
 
 $myDependency = new MyDependency($neededArguments);
 $myDependency->doSomething();
 ```
 
+This article works for any **Dotkernel 1.x** version if your server is running **PHP >5.4.0**.
+
 ## FAQ
 
 **Q: What does Composer do?**
-A: Composer is an application-level package manager. It auto-loads dependencies on demand and can also auto-load custom classes.
+A: Composer is an application-level package manager.
+It auto-loads dependencies on demand and can also auto-load custom classes.
 
 **Q: What must a Dotkernel project have before Composer can be used?**
 A: A composer.json file, for example requiring zendframework/zendframework1 at 1.12.* and mobiledetect/mobiledetectlib at 2.8.*, plus PHP >=5.4.0 listed under require-dev.
 
 **Q: What happens when you run composer update?**
-A: If the vendor folder already exists, composer checks for and applies updates to the packages. If it doesn't exist, composer creates the vendor folder containing all requested packages, along with an autoload file.
+A: If the vendor folder already exists, Composer checks for and applies updates to the packages.
+If it doesn't exist, Composer creates the vendor folder containing all requested packages, along with an autoload file.
 
 **Q: How do you safely load the Composer autoloader in case Composer isn't present?**
 A: Check whether vendor/autoload.php exists using file_exists() before calling require_once() on it, and handle the case gracefully (for example by loading fallbacks) if the path is missing.
 
 **Q: Which Dotkernel versions does this apply to?**
 A: The article states it works for any Dotkernel 1.x version, as long as the server is running PHP greater than 5.4.0.
+
+## Resources
+
+- [Composer install / PHP dependency manager tutorial](https://www.codementor.io/php/tutorial/composer-install-php-dependency-manager)
diff --git a/public/md-articles/dotkernel/adding-windows-10-os-and-browser-detection-in-dotkernel-projects.md b/public/md-articles/dotkernel/adding-windows-10-os-and-browser-detection-in-dotkernel-projects.md
index 54905d21..70cc5c14 100644
--- a/public/md-articles/dotkernel/adding-windows-10-os-and-browser-detection-in-dotkernel-projects.md
+++ b/public/md-articles/dotkernel/adding-windows-10-os-and-browser-detection-in-dotkernel-projects.md
@@ -14,24 +14,21 @@ language: "en"
 Dotkernel added Windows 8, 8.1 and 10 OS icons and a Microsoft Edge browser icon, shown in the User and Admin login icons.
 This article is the upgrade guide for applying that icon patch.
 
-Recently we have added the Windows 8, 8.1 and 10 OS icon and Microsoft's Edge browser icon.
+## Upgrade steps
 
-In this article we will have the icon upgrade guide.
+![Icons Patch](/uploads/article/019f8a80-cc47-710e-9ef1-b2257262e376/icons.png)
+*The new Icons listed in User and Admin Logins*
 
-![Icons Patch](/uploads/article/019f8a80-cc47-710e-9ef1-b2257262e376/icons.png)The new Icons listed in User and Admin Logins
+1. Make sure your project is running version **1.5.0** or **newer**.
+2. Download the [patch](http://www.dotkernel.com/download/?did=46).
+3. Extract the archive into a folder, e.g. `icons_patch`.
+4. Create a backup of your project before continuing (recommended).
+5. Copy all the files in the `icons_patch` folder into your Dotkernel project.
+6. You will be prompted to replace 2 files - replace them and agree to merge the folders' content (other files will be added, not replaced).
+7. Clear the cache for changes to take effect, since the OS and browser XMLs are cached (see "Dotkernel Reserved Variable Names for Caching", the "Browser & OS" section).
+8. You can now delete the `icons_patch` folder, or keep it to patch another project.
 
- 
-
-1. Make sure your project is running on version **1.5.0** or **newer**
-2. Download the [patch](http://www.dotkernel.com/download/?did=46)
-3. Extract the archive in a folder, let's name it **icons_patch**
-4. We recommend creating a backup of your project before you continue
-5. Now copy all the files in the **icons_patch** folder in your Dotkernel
-6. You will be prompted to replace 2 files, simply replace the files and agree to merge the folders content (files will be added, not replaced this time)
-7. You need to clear the cache for changes to take effect, the os and browser xml's are cached. For more information read [this article](http://www.dotkernel.com/dotkernel/dotkernel-reserved-variable-names-for-caching/) (look for **Browser & OS**)
-8. You can now delete the **icons_patch** folder or use it to patch another project
-
-List of affected files:
+## Affected files
 
 ```
 M /configs/useragent/browser.xml
@@ -40,9 +37,7 @@ A /images/browsers/edge.png
 A /images/os/windows_metro.png
 ```
 
-**M** stands for **modify**
-
-**A** stands for **add**
+`M` stands for **modify**, `A` stands for **add**.
 
 ## FAQ
 
@@ -57,3 +52,8 @@ A: Because the OS and browser XML files are cached, so the new icons won't show
 
 **Q: Will applying the patch overwrite existing files?**
 A: You'll be prompted to replace 2 files (browser.xml and os.xml) and should agree, and also agree to merge the folders' contents since the other files listed are added rather than replaced.
+
+## Resources
+
+- [Icon patch download](http://www.dotkernel.com/download/?did=46)
+- [Dotkernel Reserved Variable Names for Caching](http://www.dotkernel.com/dotkernel/dotkernel-reserved-variable-names-for-caching)
diff --git a/public/md-articles/dotkernel/autologin-using-cookie-remember-me-in-dotkernel.md b/public/md-articles/dotkernel/autologin-using-cookie-remember-me-in-dotkernel.md
index 85366a17..800652cd 100644
--- a/public/md-articles/dotkernel/autologin-using-cookie-remember-me-in-dotkernel.md
+++ b/public/md-articles/dotkernel/autologin-using-cookie-remember-me-in-dotkernel.md
@@ -14,17 +14,11 @@ language: "en"
 This feature automatically logs in a user who checks the "remember me" box at login.
 It has been implemented in [Dotkernel Frontend](https://github.com/dotkernel/frontend) starting from Release 3.3.0, and requires changes across the login form, a new entity/migration, a new middleware, config, and the user service/repository/controller.
 
-## Autologin using Cookie / Remember Me in Dotkernel
-
-This feature is used to automatically log the user who chooses this by checking the remember me box.
-
-Implemented in [Dotkernel Frontend](https://github.com/dotkernel/frontend) starting from Release 3.3.0.
-
 ## Add remember me button to user interface
 
-To add remember me button to user interface, navigate to **src/User/templates/user/login.html.twig** and under password element add the following code:
+Navigate to `src/User/templates/user/login.html.twig` and, under the password element, add:
 
-```
+```twig
 <div class="checkbox remember-me-checkbox">
      {% set rememberMe = form.get('rememberMe') %}
      {{ formElement(rememberMe) }}
@@ -32,9 +26,9 @@ To add remember me button to user interface, navigate to **src/User/templates/us
 </div>
 ```
 
-After you've added the button to your template, navigate to **src/User/src/Form/LoginForm.php** and add the following element to your form:
+Then navigate to `src/User/src/Form/LoginForm.php` and add the following element to your form:
 
-```
+```php
 $this->add([
     'name' => 'rememberMe',
     'type' => 'checkbox',
@@ -46,9 +40,9 @@ $this->add([
 ]);
 ```
 
-After you've added the new element navigate **src/User/src/InputFilter/LoginInputFilter.php** and add the following code, this will add a filter to the remember me element added previously.
+Then navigate to `src/User/src/InputFilter/LoginInputFilter.php` and add a filter for the new element:
 
-```
+```php
 $this->add([
             'name' => 'rememberMe',
             'filters' => [
@@ -63,9 +57,9 @@ $this->add([
         ]);
 ```
 
-To add style to your remember me button navigate to **src/App/assets/scss/components/_profile.scss** and add the following css:
+To style the button, navigate to `src/App/assets/scss/components/_profile.scss` and add:
 
-```
+```scss
 .remember-me-checkbox {
   input {
     display: block;
@@ -77,40 +71,29 @@ To add style to your remember me button navigate to **src/App/assets/scss/compon
 }
 ```
 
-After you have made all the changes it's time to compile the css in order to implement the button in interface, to do that run the following command:
+After making the changes, compile the CSS so the button styling takes effect:
 
-```
+```shell
 npm run prod
 ```
 
-## **Add functionality to remember me button**
-
-Now that you've added the button let's move on to its functionality, first you have to navigate to src/User/src/Entity, create a new entity named UserRememberMe.php and modifiy it as in [UserRememberMe](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Entity/UserRememberMe.php)
-
-After you've created the entity, you have to create migration file for the new table using the following command:
-
-```
-vendor/bin/phinx create --configuration=config/migrations.php  RememberUserSchema
-```
-
-<
-
-class="mb-3">After the migration file is created modify it as in [user_remember_schema](https://www.dotkernel.com/dotkernel/autologin-using-cookie-remember-me-in-dotkernel/) and run the following command to add it to you database:
-
-```
-vendor/bin/phinx migrate --configuration=config/migrations.php
-```
-
-The table generated by migration is used to store data from coockie. The stored data will help to login the user utomatically.
-
-The next step is to create a new middleware, navigate to **src/App/src/Middleware** and create a new file named **RememberMeMiddleware.php** and modify it as in [RememberMeMiddleware](https://github.com/dotkernel/frontend/blob/3.0/src/App/src/Middleware/RememberMeMiddleware.php).
-
-After you've created the new middleware navigate to **config/pipeline.php** and add it as in [pipeline](https://github.com/dotkernel/frontend/blob/3.0/config/pipeline.php).
-
-In order to generate the cookie in the next steps you have to add a new key to your local.php, to do that navigate to **config/autoload/local.php** and add the following code:
-
-```
-'rememberMe' => [
+## Add functionality to remember me button
+
+1. Navigate to `src/User/src/Entity`, create a new entity named `UserRememberMe.php`, modeled on [UserRememberMe](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Entity/UserRememberMe.php).
+2. Create a migration file for the new table:
+   ```shell
+   vendor/bin/phinx create --configuration=config/migrations.php  RememberUserSchema
+   ```
+3. Modify the generated migration file as in [user_remember_schema](https://www.dotkernel.com/dotkernel/autologin-cookie-remember-me-feature/), then run it against the database:
+   ```shell
+   vendor/bin/phinx migrate --configuration=config/migrations.php
+   ```
+   The table generated by the migration is used to store data from the cookie, which helps log the user in automatically.
+4. Create a new middleware at `src/App/src/Middleware/RememberMeMiddleware.php`, modeled on [RememberMeMiddleware](https://github.com/dotkernel/frontend/blob/3.0/src/App/src/Middleware/RememberMeMiddleware.php).
+5. Register the middleware in `config/pipeline.php` as shown in [pipeline](https://github.com/dotkernel/frontend/blob/3.0/config/pipeline.php).
+6. To generate the cookie, add a new key to `config/autoload/local.php`:
+   ```php
+   'rememberMe' => [
             'cookie' => [
                 'name' => 'rememberMe',
                 'lifetime' => 3600 * 24 * 30,
@@ -119,15 +102,10 @@ In order to generate the cookie in the next steps you have to add a new key to y
                 'httponly' => true
             ]
         ],
-```
-
-In the following step you have to edit your **src/User/src/Service/UserService.php**. First you have to add 2 new properties, **$defaultSessionManager** used to get config and **$repository** used to get repository. After you have added those properties add the following methods: **getRepository(), addRememberMeToken(), deleteRememberMeCookie()**. as in [UserService](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Service/UserService.php).
-
-(don't forget to add all new methods to interface if needed)
-
-Now, let's move to **src/User/src/Repository/UserRepository.php** and add the following methods: **saveRememberUser(), getRememberUser(), findRememberMeUser(), deleteExpiredCookies(), removeRememberUser()** as in [UserRepository](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Repository/UserRepository.php).
-
-The last step is to go to **src/User/src/Controller/UserController.php**, add a new property called **$config** and edit your **loginAction()** and **logoutAction()** as in [UserController](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Controller/UserController.php).
+   ```
+7. Edit `src/User/src/Service/UserService.php`: add two new properties, `$defaultSessionManager` (to get config) and `$repository` (to get repository), then add the methods `getRepository()`, `addRememberMeToken()`, `deleteRememberMeCookie()` as in [UserService](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Service/UserService.php) (and add the new methods to the interface if needed).
+8. Edit `src/User/src/Repository/UserRepository.php` and add the methods `saveRememberUser()`, `getRememberUser()`, `findRememberMeUser()`, `deleteExpiredCookies()`, `removeRememberUser()` as in [UserRepository](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Repository/UserRepository.php).
+9. Edit `src/User/src/Controller/UserController.php`: add a new property called `$config`, and edit `loginAction()` and `logoutAction()` as in [UserController](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Controller/UserController.php).
 
 ## FAQ
 
@@ -148,3 +126,14 @@ A: It's used to store data from the cookie, which helps log the user in automati
 
 **Q: How do you apply the new remember-me button styles?**
 A: Add the CSS to src/App/assets/scss/components/_profile.scss, then run npm run prod to compile the CSS so the button styling takes effect.
+
+## Resources
+
+- [Dotkernel Frontend on GitHub](https://github.com/dotkernel/frontend)
+- [UserRememberMe entity example](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Entity/UserRememberMe.php)
+- [Remember user schema migration example](https://www.dotkernel.com/dotkernel/autologin-cookie-remember-me-feature/)
+- [RememberMeMiddleware example](https://github.com/dotkernel/frontend/blob/3.0/src/App/src/Middleware/RememberMeMiddleware.php)
+- [pipeline.php example](https://github.com/dotkernel/frontend/blob/3.0/config/pipeline.php)
+- [UserService example](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Service/UserService.php)
+- [UserRepository example](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Repository/UserRepository.php)
+- [UserController example](https://github.com/dotkernel/frontend/blob/3.0/src/User/src/Controller/UserController.php)
diff --git a/public/md-articles/dotkernel/avoid-routing-through-bootstrap-of-non-existent-files.md b/public/md-articles/dotkernel/avoid-routing-through-bootstrap-of-non-existent-files.md
index afb7281f..f93fa85d 100644
--- a/public/md-articles/dotkernel/avoid-routing-through-bootstrap-of-non-existent-files.md
+++ b/public/md-articles/dotkernel/avoid-routing-through-bootstrap-of-non-existent-files.md
@@ -10,25 +10,24 @@ language: "en"
 
 # Avoid routing through bootstrap of non existent files
 
-In some cases you may encounter missing files: images, css or js files. All those missing files are processed by the current bootstrap: index.php
+In some cases you may encounter missing files: images, CSS, or JS files.
+All those missing files are processed by the current bootstrap: `index.php`.
 
-If the session is set to regenerate on each request, as a normal security measure, the currently logged user is logged off, because the session ID is different now.
+If the session is set to regenerate on each request, as a normal security measure, the currently logged-in user is logged off, because the session ID is different now.
 
-To avoid this, **below** the following line
+To avoid this, below the following line:
 
 ```
 RewriteEngine On
 ```
 
-add the line :
+add the line:
 
 ```
-RewriteCond %{REQUEST_FILENAME} (\.gif|\.jpg|\.png|\.css|\.js)$ [OR]
+RewriteCond %{REQUEST_FILENAME} (\.gif|\.jpg|\.png|\.css|\.js)$
 ```
 
-Save and don't forget to test.
-
-Even though it's a well known fact that real men do not test...
+Save, and don't forget to test.
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel/caching-in-dotkernel-using-zend-framework.md b/public/md-articles/dotkernel/caching-in-dotkernel-using-zend-framework.md
index 0f2c488e..ab301054 100644
--- a/public/md-articles/dotkernel/caching-in-dotkernel-using-zend-framework.md
+++ b/public/md-articles/dotkernel/caching-in-dotkernel-using-zend-framework.md
@@ -14,34 +14,26 @@ language: "en"
 Loading configuration and settings from XML files on every request is expensive, both due to hard-drive latency and XML parsing overhead.
 Dotkernel 1.8 implements a cache layer for router, acl_role, menu, options (including seo_xml), browser_xml, os_xml and test data, with a choice of APC/APCU or file-based storage.
 
-It's very expensive to load configurations and settings from XML files, on every requests.
-
-First because of latency of accessing files from hard drive, second because of the XML file parsing burden.
-
-Because of that , we implemented in upcoming 1.8 version of Dotkernel a cache layer where to store **router, acl_role, menu, options(including seo_xml), browser_xml, os_xml, test** between requests. More information about the variables which Dotkernel cache by default follow this link: [Dotkernel Reserved Variable Names for Caching](http://www.dotkernel.com/dotkernel/dotkernel-reserved-variable-names-for-caching)
-
-We are implementing 2 different cache factories to choose from: **apc** (or **apcu** for newest PHP installations) and **file**.
-
 ## 1. Configuring the cache
 
-The configuration can be set from /configs/application.ini, you can choose if you use the caching system, how long your cache stays valid, the cache namespace, and the storage provider (**File** or **APC**). I would disable the cache in development mode if I were you.
-
-For more info about the configuration and help configuring the cache see: [Configuring the Cache in Dotkernel](http://www.dotkernel.com/dotkernel/configuring-the-cache-in-dotkernel/).
-
-## 2. Using the Cache
+The configuration is set from `/configs/application.ini`: whether caching is enabled, how long the cache stays valid, the cache namespace, and the storage provider (File or APC).
+The article recommends disabling the cache in development mode.
+See [Configuring the Cache in Dotkernel](http://www.dotkernel.com/dotkernel/configuring-the-cache-in-dotkernel/) for more details.
 
-The cache is automatically loaded in the initialization and stored in the Registry.
+## 2. Using the cache
 
-Loading the caching engine is not needed because it is already loaded on kernel initialization (*see **Dot_Kernel**::**initialize**($startTime)*)*,* but if you would like to use caching for other purposes (where you are not initializing the kernel), the loading syntax is the following:
+The cache is automatically loaded during initialization and stored in the Registry - loading it manually is not needed because it's already loaded on kernel initialization (see `Dot_Kernel::initialize($startTime)`).
+If you want to use caching outside of that normal initialization, load it with:
 
-```
+```php
 Dot_Cache::loadCache();
 ```
 
-Below is a simple object caching sample, yes, you can also cache objects. 
- Note: The cache key must match the following RegEx pattern: **[A-Za-z0-9_]***
+Note: the cache key must match a specific RegEx pattern.
 
-```
+Example of object caching:
+
+```php
 $id = 'MyCachedKey';
 $obj = new stdClass();
 $obj->text = 'I am a cached text';
@@ -53,13 +45,10 @@ Dot_Cache::save(obj, $id);
 $value = Dot_Cache::load($id);
 
 // checking if we have the object in cache
-if($value !== false)
-{
+if ($value !== false) {
      // assuming we only need the text value from the object
      echo $value->text;
-}
-else
-{
+} else {
      echo 'no value cached for '. $id ;
 }
 ```
@@ -73,10 +62,17 @@ A: Router, acl_role, menu, options (including seo_xml), browser_xml, os_xml, and
 A: Two cache factories to choose from: APC (or APCU for newer PHP installations) and File.
 
 **Q: Where is the cache configured?**
-A: In /configs/application.ini, where you can enable or disable caching, set how long the cache stays valid, choose the cache namespace, and pick the storage provider (File or APC). The article recommends disabling the cache in development mode.
+A: In /configs/application.ini, where you can enable or disable caching, set how long the cache stays valid, choose the cache namespace, and pick the storage provider (File or APC).
+The article recommends disabling the cache in development mode.
 
 **Q: Do you need to manually load the cache engine?**
-A: No, it's automatically loaded during kernel initialization (Dot_Kernel::initialize()). Manually calling Dot_Cache::loadCache() is only needed if you want to use caching outside of that normal initialization.
+A: No, it's automatically loaded during kernel initialization (Dot_Kernel::initialize()).
+Manually calling Dot_Cache::loadCache() is only needed if you want to use caching outside of that normal initialization.
 
 **Q: Can you cache PHP objects, not just simple values?**
 A: Yes, the article shows an example of saving and loading a stdClass object using Dot_Cache::save() and Dot_Cache::load().
+
+## Resources
+
+- [Dotkernel Reserved Variable Names for Caching](http://www.dotkernel.com/dotkernel/dotkernel-reserved-variable-names-for-caching)
+- [Configuring the Cache in Dotkernel](http://www.dotkernel.com/dotkernel/configuring-the-cache-in-dotkernel/)
diff --git a/public/md-articles/dotkernel/camelcase-table-names-in-mysql-on-windows.md b/public/md-articles/dotkernel/camelcase-table-names-in-mysql-on-windows.md
index 1313b261..5c545ac5 100644
--- a/public/md-articles/dotkernel/camelcase-table-names-in-mysql-on-windows.md
+++ b/public/md-articles/dotkernel/camelcase-table-names-in-mysql-on-windows.md
@@ -10,15 +10,15 @@ language: "en"
 
 # camelCase Table Names in MySQL on Windows
 
-If you are using a WAMP stack, like WAMP or XAMPP, and try to create a table in camelCase ( example: **adminLogin**) you will notice that camelCase is not working, table name will be lowercase: **adminlogin**. In order to fix this, you need to add to your my.cnf file the line:
+If you are using a WAMP stack, like WAMP or XAMPP, and try to create a table in camelCase (example: `adminLogin`), you will notice that camelCase is not working - the table name will be lowercase: `adminlogin`.
+
+In order to fix this, add the following line to your `my.cnf` file:
 
 ```
 lower_case_table_names=2
 ```
 
-and restart mysql.
-
-More on that here: [http://dev.mysql.com/doc/refman/4.1/en/server-system-variables.html#sysvar_lower_case_table_names](http://dev.mysql.com/doc/refman/4.1/en/server-system-variables.html#sysvar_lower_case_table_names)
+and restart MySQL.
 
 ## FAQ
 
@@ -26,4 +26,8 @@ More on that here: [http://dev.mysql.com/doc/refman/4.1/en/server-system-variabl
 A: A table created with a camelCase name, for example adminLogin, ends up stored as all lowercase, e.g. adminlogin, instead.
 
 **Q: How do you fix it?**
-A: Add the line lower_case_table_names=2 to your my.cnf file and restart MySQL.
+A: Add the line `lower_case_table_names=2` to your my.cnf file and restart MySQL.
+
+## Resources
+
+- [MySQL lower_case_table_names documentation](http://dev.mysql.com/doc/refman/4.1/en/server-system-variables.html#sysvar_lower_case_table_names)
diff --git a/public/md-articles/dotkernel/commitment-to-php-new-zend-certified-engineers-zce-in-our-team.md b/public/md-articles/dotkernel/commitment-to-php-new-zend-certified-engineers-zce-in-our-team.md
index b05b7966..2b43175d 100644
--- a/public/md-articles/dotkernel/commitment-to-php-new-zend-certified-engineers-zce-in-our-team.md
+++ b/public/md-articles/dotkernel/commitment-to-php-new-zend-certified-engineers-zce-in-our-team.md
@@ -11,14 +11,16 @@ language: "en"
 # Commitment to PHP - new Zend Certified Engineers - ZCE - in our team
 
 Another 2 of our team members passed the ZCE exam.
+Now we are 5.
+That means we are really taking PHP into serious consideration, and at the very least we have good technical skills.
 
-Now we are 5 :-)
-
-That mean we are really taking PHP  into serious , and at least we have good technical skills.
-
-[Zend Yellow Pages](http://www.zend.com/store/education/certification/yellow-pages.php#list-cid=0&sid=&certtype_zf=1&certtype_php=1&certtype=&firstname=&lastname=&company=Dotboost%20Technologies&ClientCandidateID=)
+See the [Zend Yellow Pages](http://www.zend.com/store/education/certification/yellow-pages.php#list-cid=0&sid=&certtype_zf=1&certtype_php=1&certtype=&firstname=&lastname=&company=Dotboost%20Technologies&ClientCandidateID=).
 
 ## FAQ
 
 **Q: How many Zend Certified Engineers does the team have?**
 A: According to the article, 2 more team members passed the ZCE exam, bringing the team's total to 5 Zend Certified Engineers.
+
+## Resources
+
+- [Zend Yellow Pages listing](http://www.zend.com/store/education/certification/yellow-pages.php#list-cid=0&sid=&certtype_zf=1&certtype_php=1&certtype=&firstname=&lastname=&company=Dotboost%20Technologies&ClientCandidateID=)
diff --git a/public/md-articles/dotkernel/configuring-the-cache-in-dotkernel.md b/public/md-articles/dotkernel/configuring-the-cache-in-dotkernel.md
index aa515e28..ccbd0279 100644
--- a/public/md-articles/dotkernel/configuring-the-cache-in-dotkernel.md
+++ b/public/md-articles/dotkernel/configuring-the-cache-in-dotkernel.md
@@ -11,53 +11,46 @@ language: "en"
 # Configuring the Cache in Dotkernel
 
 ## TL;DR
+
 Dotkernel's caching layer is built on Zend Framework Cache and is configured through `cache.*` settings in `application.ini`.
 The main frontend settings control whether caching is enabled, which cache service to use, the namespace prefix, and how long entries live.
 Optional backend-specific settings (like the file cache directory) are recommended so that separate projects don't accidentally share the same cache.
 
 This article contains the Dotkernel cache layer configuration guide.
-
-The Dotkernel Caching Layer is based on Zend Framework Cache, more configuration options can be found at the following links:
+The Dotkernel Caching Layer is based on Zend Framework Cache; more configuration options can be found at the following links:
 
 - [Zend Framework Cache Frontends](http://framework.zend.com/manual/1.12/en/zend.cache.frontends.html)
 - [Zend Framework Cache Backends](http://framework.zend.com/manual/1.12/en/zend.cache.backends.html)
 
-## Main cache settings (Cache Frontend)
+## Main Cache Settings (Cache Frontend)
 
-The main cache settings within the **application.ini** file should look like this:
+The main cache settings within the application.ini file should look like this:
 
-```
+```ini
 cache.enable = true
 cache.factory = "apc"
 cache.lifetime = "86400"
 cache.namespace = "dotkernel"
 ```
 
-The *cache.enable* option can be used to disable caching, mostly used in development stage.
-
-The *cache.factory* value will be the cache service we want to use: ***file*** or ***apc***
-
-The *cache.namespace* will be the cache variables prefix and the *cache.lifetime* value will define how long the variables cached will be usable before they will need to be re-cached.
+The cache.enable option can be used to disable caching, mostly used in the development stage.
+The cache.factory value will be the cache service we want to use: file or apc.
+The cache.namespace will be the cache variables prefix, and the cache.lifetime value will define how long the cached variables will be usable before they need to be re-cached.
 
- 
+## Individual Cache Settings (Cache Backend)
 
-## Individual cache settings (Cache Backend)
+The individual cache settings are optional, but it's highly recommended that you have these values set, otherwise other projects might use the same cache.
 
-The individual cache settings are optional but we highly recommend that you have theese values set, otherwise other projects might use the same cache
-
-```
+```ini
 ; file caching settings
- cache.file.cache_dir = APPLICATION_PATH "/cache"
- cache.file.cache_file_perm = 0600
+cache.file.cache_dir = APPLICATION_PATH "/cache"
+cache.file.cache_file_perm = 0600
 ```
 
- 
-
-For more settings and caching alternatives see the Zend Framework Cache Links at the article beginning.
-
+For more settings and caching alternatives, see the Zend Framework Cache links at the beginning of the article.
 The setting pattern and sample are below:
 
-```
+```ini
 cache.BACKEND_NAME.SETTING = "VALUE"
 ; example:
 cache.file.file_name_prefix = "Dotkernel"
diff --git a/public/md-articles/dotkernel/dependency-injection-made-easy-in-laminas-mezzio-applications.md b/public/md-articles/dotkernel/dependency-injection-made-easy-in-laminas-mezzio-applications.md
index 6d80f383..7b9fa486 100644
--- a/public/md-articles/dotkernel/dependency-injection-made-easy-in-laminas-mezzio-applications.md
+++ b/public/md-articles/dotkernel/dependency-injection-made-easy-in-laminas-mezzio-applications.md
@@ -11,23 +11,27 @@ language: "en"
 # Dependency Injection made easy in Laminas/Mezzio applications
 
 ## TL;DR
+
 Dotkernel's dot-dependency-injection package autowires constructor dependencies in Laminas/Mezzio (and other PSR-11) applications, removing the need to write and maintain a custom factory class for every service.
 Instead of a bespoke factory, you add an attribute to the class constructor and register a single shared AttributedServiceFactory in your ConfigProvider.
 The package requires Doctrine ORM but can still be used in applications that don't integrate Doctrine, and it also supports injecting Doctrine repositories directly instead of fetching them from the EntityManager.
 
-> **Note**: The package requires Doctrine ORM. Still, it can be used in applications which do not integrate Doctrine.
+> Note: The package requires Doctrine ORM. Still, it can be used in applications which do not integrate Doctrine.
 
 So, first thing first, the problem.
+You have a Laminas / Mezzio application with a bunch of services that you need to use in a, let's say, controller class or in any other class, and you are tired of building, updating, and maintaining factories every time you add a new dependency to your class.
 
-You have a **Laminas / Mezzio** application with a bunch of services that you need to use in a, let's say, controller class or in any other class, and you are tired of building, updating, and maintaining factories every time you add a new dependency to your class.
-
-**Dotkernel** has you covered. We built a **tool to autowire those dependencies in your class**. There is no need for factories for every class you make. Just use one “factory” class that you tie to your custom class in the config, and that's it.
+Dotkernel has you covered.
+We built a tool to autowire those dependencies in your class.
+There is no need for factories for every class you make.
+Just use one "factory" class that you tie to your custom class in the config, and that's it.
 
-Sounds easy, right? Let’s finish with the chat and speak some code, first showing the problem and then the solution.
+Sounds easy, right?
+Let's finish with the chat and speak some code, first showing the problem and then the solution.
 
-> The examples below are from the **[Dotkernel API framework](https://github.com/dotkernel/api)**, but the pattern applies to all **laminas** and **mezzio** applications and to all PSR-11 applications.
+> The examples below are from the [Dotkernel API framework](https://github.com/dotkernel/api), but the pattern applies to all laminas and mezzio applications and to all PSR-11 applications.
 
-```
+```php
 class UserHandler implements RequestHandlerInterface
 {
     public function __construct(
@@ -38,9 +42,10 @@ class UserHandler implements RequestHandlerInterface
 }
 ```
 
-Above, we have a **UserHandler** (Controller), and we have the required dependencies: `UserService `and `config`. Normally, we would build a factory for this to get things from the container and put them in the config provider like this:
+Above, we have a UserHandler (Controller), and we have the required dependencies: `UserService` and `config`.
+Normally, we would build a factory for this to get things from the container and put them in the config provider like this:
 
-```
+```php
 class UserHandlerFactory
 {
     /**
@@ -61,7 +66,7 @@ class UserHandlerFactory
 
 And in the config provider, we would have the following:
 
-```
+```php
 public function getDependencies(): array
 {
     return
@@ -69,9 +74,9 @@ public function getDependencies(): array
 }
 ```
 
-In one more example, let's look at the real-world required dependencies for `UserService`, the dependency that is required for `UserHandle`.
+In one more example, let's look at the real-world required dependencies for `UserService`, the dependency that is required for `UserHandler`.
 
-```
+```php
 class UserService implements UserServiceInterface
 {
     public function __construct(
@@ -90,21 +95,20 @@ class UserService implements UserServiceInterface
 }
 ```
 
-Now consider that we need to build the factory for this and update it when we add a new dependency, and so on. Also to build the logic in the factory to handle any dependencies missing from the container. Painful right?
+Now consider that we need to build the factory for this and update it when we add a new dependency, and so on.
+We'd also need to build the logic in the factory to handle any dependencies missing from the container.
+Painful, right?
 
-Now let's use **Dotkernel's** [dot-dependency-injection](https://github.com/dotkernel/dot-dependency-injection) package to inject the required dependency into your class.
+Now let's use Dotkernel's [dot-dependency-injection](https://github.com/dotkernel/dot-dependency-injection) package to inject the required dependency into your class.
 
-After you install the package, your class needs to `use Dot\DependencyInjection\Attribute\Inject` , then you need to add the `#[Inject(...)]` attribute to the constructor definition to specify which dependencies should be injected.
+After you install the package, your class needs to `use Dot\DependencyInjection\Attribute\Inject`, then you need to add the `#` attribute to the constructor definition to specify which dependencies should be injected.
 
-```
+```php
 use Dot\DependencyInjection\Attribute\Inject;
 
 class UserHandler implements RequestHandlerInterface
 {
-    #[Inject(
-        UserServiceInterface::class,
-        "config",
-    )]
+    #
     public function __construct(
         protected UserServiceInterface $userService,
         protected array $config,
@@ -113,9 +117,9 @@ class UserHandler implements RequestHandlerInterface
 }
 ```
 
-Add the `Dot\DependencyInjection\Factory\AttributedServiceFactory` class to your `ConfigProvider`
+Add the `Dot\DependencyInjection\Factory\AttributedServiceFactory` class to your `ConfigProvider`:
 
-```
+```php
 public function getDependencies(): array
 {
     return
@@ -123,11 +127,12 @@ public function getDependencies(): array
 }
 ```
 
-That's right, the ``AttributedServiceFactory` `class is the only one you need to add to your config, so you are ready to go. This class will "build" the factory for you and will handle all the logic if any dependencies are not found in the container with appropriate exceptions and messages.
+That's right, the `AttributedServiceFactory` class is the only one you need to add to your config, so you are ready to go.
+This class will "build" the factory for you and will handle all the logic if any dependencies are not found in the container, with appropriate exceptions and messages.
 
 One more time, let's see how the `UserService` will look now.
 
-```
+```php
 class UserService implements UserServiceInterface
 {
     use Dot\DependencyInjection\Attribute\Inject;
@@ -150,9 +155,10 @@ class UserService implements UserServiceInterface
 }
 ```
 
-## And, that's not all.
+## And, That's Not All.
 
-If you use doctrine and repository pattern and you don't want to get your repository from `EntityManager` and want to inject it into your service, this package covers that too. The principle is the same, and for more insight about this, you can check the package documentation at [dot-dependency-injection](https://docs.dotkernel.org/dot-dependency-injection/).
+If you use Doctrine and the repository pattern and you don't want to get your repository from `EntityManager` and want to inject it into your service, this package covers that too.
+The principle is the same, and for more insight about this, you can check the package documentation at [dot-dependency-injection](https://docs.dotkernel.org/dot-dependency-injection/).
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel/detecting-mobile-devices-in-dotkernel-1-6-0.md b/public/md-articles/dotkernel/detecting-mobile-devices-in-dotkernel-1-6-0.md
index e9914ae1..a5b236aa 100644
--- a/public/md-articles/dotkernel/detecting-mobile-devices-in-dotkernel-1-6-0.md
+++ b/public/md-articles/dotkernel/detecting-mobile-devices-in-dotkernel-1-6-0.md
@@ -11,27 +11,24 @@ language: "en"
 # Detecting Mobile Devices in Dotkernel 1.6.0
 
 ## TL;DR
+
 Dotkernel 1.6.0 no longer ships with a working built-in mobile detection method, because mobile detection now relies on the new Wurfl Cloud integration and must be configured via a Wurfl Cloud account and API key.
 The old Dot_UserAgent_Wurfl class was removed and replaced by Dot_UserAgent_WurflCloud, which uses the Wurfl Cloud API adapter.
 The article walks through the application.ini settings and shows sample code for reading device info and redirecting mobile visitors.
 
-The new Dotkernel version 1.6.0 is comming with some changes how we are detecting mobile devices, this changes are because of the new Wurfl Cloud integration.
-
-This version of Dotkernel is not comming anymore with a working built in method for mobile detection, so first we have to configure it.
-
-- go to scientiamobile website and register for an Wurfl Cloud account
-- choose **device_os** and **mobile_browser** to your account and save
-- go to API Keys and copy the right key in application.ini
-
- 
+The new Dotkernel version 1.6.0 is coming with some changes to how we detect mobile devices; these changes are because of the new Wurfl Cloud integration.
+This version of Dotkernel no longer comes with a working built-in method for mobile detection, so first we have to configure it.
 
-We choosed device_os and mobile_browser capabilities because with these two capabilities we can get some extra capabilities (isMobile, isSmartPhone, isIphone, isAndroid, isBlackberry, is Symbian and is WindowsMobile) using our built in methods.
+- Go to the scientiamobile website and register for a Wurfl Cloud account.
+- Choose device_os and mobile_browser for your account and save.
+- Go to API Keys and copy the right key into application.ini.
 
-Choosing other capabilities from scientiamobile will result in wrong detection of these extra capabilities, but you can get only those capabilities using another method from Dot_UserAgent_WurflCloud class.
+We chose device_os and mobile_browser capabilities because with these two capabilities we can get some extra capabilities (isMobile, isSmartPhone, isIphone, isAndroid, isBlackberry, isSymbian, and isWindowsMobile) using our built-in methods.
+Choosing other capabilities from scientiamobile will result in wrong detection of these extra capabilities, but you can get only those capabilities using another method from the Dot_UserAgent_WurflCloud class.
 
-Wurfl Cloud setting in application.ini
+Wurfl Cloud setting in application.ini:
 
-```
+```ini
 resources.useragent.wurflcloud.active = TRUE
 resources.useragent.wurflcloud.redirect = TRUE
 resources.useragent.wurflcloud.cache = TRUE
@@ -41,23 +38,29 @@ resources.useragent.wurflcloud.api_key = 000000:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 resources.useragent.wurflcloud.lib_dir = APPLICATION_PATH "/library/WurflCloud/"
 ```
 
-**active** - used to turn on (TRUE) or off (FALSE) the wurfl cloud detection (default: TRUE) **redirect** - if is TRUE your visitators from frontend will be redirected to mobile module (default: TRUE) **cache** - cache every distinct result to optimize the number of requests to scientiamobile (default: TRUE) **cache_lifetime** - time in seconds to keep the results in cache (default: 3600) **cache_namespace** - the prefix used for cache keys (default: WURFLCLOUD) **api_key** - API Key from WURFL Cloud account (change this with your key) **lib_dir** - the wurfl cloud library location in Dotkernel (don't change this, just if you want to move the library)
+- active - used to turn on (TRUE) or off (FALSE) the Wurfl Cloud detection (default: TRUE).
+- redirect - if TRUE, visitors from the frontend will be redirected to the mobile module (default: TRUE).
+- cache - caches every distinct result to optimize the number of requests to scientiamobile (default: TRUE).
+- cache_lifetime - time in seconds to keep the results in cache (default: 3600).
+- cache_namespace - the prefix used for cache keys (default: WURFLCLOUD).
+- api_key - the API key from your WURFL Cloud account (change this to your own key).
+- lib_dir - the Wurfl Cloud library location in Dotkernel (don't change this, unless you want to move the library).
 
-Because of these changes we removed the old Dot_UserAgent_Wurfl class and added the new one Dot_UserAgent_WurflCloud wich is using the Wurfl Cloud API adapter.
+Because of these changes, we removed the old Dot_UserAgent_Wurfl class and added the new Dot_UserAgent_WurflCloud class, which uses the Wurfl Cloud API adapter.
 
-## Example of Dot_UserAgent usage in Dotkernel:
+## Example of Dot_UserAgent Usage in Dotkernel
 
-Get Wurfl configuration
+Get Wurfl configuration:
 
-```
+```php
 $wurflConf = $registry->configuration->resources->useragent->wurflcloud;
 ```
 
-Note: You can have more Wurfl configurations if you have more libraries like Wurfl Package (GPL)
+Note: you can have more Wurfl configurations if you have more libraries, like the Wurfl Package (GPL).
 
-If Wurfl is active then get device info
+If Wurfl is active, then get device info:
 
-```
+```php
 if($wurflConf->active)
 {
     $deviceInfo = Dot_UserAgent :: getDeviceInfo($_SERVER);
@@ -65,9 +68,9 @@ if($wurflConf->active)
 }
 ```
 
-If detected device is an mobile device we will save device info in database and redirect it to the mobile controller
+If the detected device is a mobile device, we save the device info in the database and redirect it to the mobile controller:
 
-```
+```php
 if( (0 < count((array)$deviceInfo)) && $deviceInfo->isMobile)
 {
 
diff --git a/public/md-articles/dotkernel/disable-wurfl-redirect-for-mobile-browsers.md b/public/md-articles/dotkernel/disable-wurfl-redirect-for-mobile-browsers.md
index 7ef958a2..8dab81ae 100644
--- a/public/md-articles/dotkernel/disable-wurfl-redirect-for-mobile-browsers.md
+++ b/public/md-articles/dotkernel/disable-wurfl-redirect-for-mobile-browsers.md
@@ -11,23 +11,24 @@ language: "en"
 # Disable Wurfl redirect for mobile browsers
 
 ## TL;DR
+
 Dotkernel's example mobile site normally relies on Wurfl to detect mobile browsers and automatically redirect visitors there on their first homepage view, which isn't always desired.
 As of revision 408, this behavior is controlled by a single `resources.useragent.wurflapi.redirect` setting in application.ini.
 The article shows that setting along with the matching condition in `IndexController.php` that checks it before registering and redirecting a visit.
 
 Dotkernel has an example mobile site at [http://v1.dotkernel.net/mobile](http://v1.dotkernel.net/mobile) that uses [jQuery Mobile](http://jquerymobile.com/).
+Wurfl is also used to detect mobile browsers (as discussed in a [previous blog post](http://www.dotkernel.com/dotkernel/wurfl-zend-framework-integration-into-dotkernel/)) and automatically redirect them to the mobile site the first time they view the homepage.
+Sometimes this behavior isn't desired (for example when you don't have a mobile site, or you don't plan on using Wurfl at all).
 
-Wurfl is also used to detect mobile browsers (as discussed in a [previous blog post](http://www.dotkernel.com/dotkernel/wurfl-zend-framework-integration-into-dotkernel/)) and automatically redirect them to the mobile site the first time they view the homepage. Sometimes, this behavior isn't desired (for example when you don't have a mobile site, or you don't plan on using Wurfl at all)
-
-Starting with revision 408, there's an option in **application.ini** to disable the automatic redirect (by default the redirect is disabled):
+Starting with revision 408, there's an option in application.ini to disable the automatic redirect (by default the redirect is disabled):
 
-```
+```ini
 resources.useragent.wurflapi.redirect = false
 ```
 
-The following condition is also added to **Controllers/frontend/IndexController.php** (at line 19) to check the configuration:
+The following condition is also added to Controllers/frontend/IndexController.php (at line 19) to check the configuration:
 
-```
+```php
 //if automatic redirect is enabled in application.ini and the browser is mobile and session->mobileHit is not set, register it and redirect
 if($config->resources->useragent->wurflapi->redirect && 'mobile' == Dot_Kernel::getDevice()->getType() && !isset($session->mobileHit))
 ```
diff --git a/public/md-articles/dotkernel/disambiguation-dotkernel-1-and-dotkernel-3.md b/public/md-articles/dotkernel/disambiguation-dotkernel-1-and-dotkernel-3.md
index 6cd90015..77ec8032 100644
--- a/public/md-articles/dotkernel/disambiguation-dotkernel-1-and-dotkernel-3.md
+++ b/public/md-articles/dotkernel/disambiguation-dotkernel-1-and-dotkernel-3.md
@@ -11,17 +11,18 @@ language: "en"
 # Disambiguation: Dotkernel 1 and Dotkernel 3
 
 ## TL;DR
+
 Dotkernel 1 is the original PHP Application Framework built on Zend Framework 1 with an MVC architecture, released in 2010 and now in bugfix-only mode at version 1.8 LTS.
 Dotkernel 3 is a newer collection of PSR-7 middleware applications built on the Zend Expressive microframework and Zend Framework 3 components, implementing PSR-1, PSR-2, PSR-4, PSR-7, and PSR-11.
 Since Dotkernel 3's release, the unqualified name "Dotkernel" refers to Dotkernel 3, while Dotkernel 1 is always referenced explicitly.
 
-## What is the meaning behind 'Dotkernel'?
+## What Is the Meaning Behind 'Dotkernel'?
 
 The name **Dotkernel** symbiotically combines the string **Dot,** as a representation of the Internet, and **Kernel**, the quintessential components of any IT application.
 
 In other words, **Dotkernel** aims to become the starting point for development Internet applications and hence ensure increased development productivity and run-time performance.
 
-## What was Dotkernel 1?
+## What Was Dotkernel 1?
 
 Dotkernel 1 was a ***PHP* *Application Framework***, built on top of Zend Framework 1 (ZF1).
 
@@ -29,7 +30,7 @@ It had the first public release in July 2010. It was tightly coupled with **Zend
 
 The latest version is **1.8 Long Term Support**. It will not be getting any new releases or bugfixes because Zend Framework 1 is also not supported. If you are still using either Dotkernel 1 or Zend Framework 1, you need to refactor your code to the [Dotkernel Headless Platform](https://docs.dotkernel.org/headless-documentation/).
 
-## What is Dotkernel?
+## What Is Dotkernel?
 
 A **collection** of PSR-15 Middleware applications built on top of the [**Mezzio**](https://docs.mezzio.dev/mezzio/v3/getting-started/quick-start/) microframework. It is composed of a set of custom and extended [**Laminas**](https://docs.laminas.dev/) components.
 
@@ -38,8 +39,8 @@ Dotkernel architecture is based on **Middleware**. Dotkernel implements the foll
 Currently, there are three applications:
 
 - API
- - Admin
- - Queue
+- Admin
+- Queue
 
 ## Dotkernel = Dotkernel 1 or the new Dotkernel?
 
@@ -48,7 +49,7 @@ In posts older than 2017 **Dotkernel 1** was referred to as **Dotkernel** becaus
 ## FAQ
 
 **Q: What does the name "Dotkernel" mean?**
-A: It combines "Dot", as a representation of the Internet, with "kernel", the quintessence of any IT application, reflecting the aim of being a central part of Internet development.
+A: It combines "Dot", as a representation of the Internet, with "Kernel", the quintessence of any IT application, reflecting the aim of being a central part of Internet development.
 
 **Q: What is Dotkernel 1?**
 A: A PHP Application Framework built on top of Zend Framework 1, first publicly released in July 2010, with an architecture based on MVC. Its latest version is 1.8 Long Term Support, which per the article will not be followed by a new version, only bugfixes.
diff --git a/public/md-articles/dotkernel/doctrine-cache-using-symfony-cache.md b/public/md-articles/dotkernel/doctrine-cache-using-symfony-cache.md
index c6c70efc..0e653cf3 100644
--- a/public/md-articles/dotkernel/doctrine-cache-using-symfony-cache.md
+++ b/public/md-articles/dotkernel/doctrine-cache-using-symfony-cache.md
@@ -11,15 +11,21 @@ language: "en"
 # Doctrine cache using symfony/cache
 
 ## TL;DR
+
 Caching stores data the first time it's requested so that later requests can be served from the cache instead of the original, slower source, which improves response times.
 This article, a follow-up to an earlier caching article, shows how to enable the dot-cache component, a wrapper around symfony/cache, in Dotkernel Admin.
 It covers the array and filesystem storage adapters, configuring Doctrine's four cache types (result, metadata, query, hydration), and marking entities and queries as cacheable.
 
-When it comes to web development, performance is one of the critical elements that influence the success of an application. Developers focus on improving response times and overall speed to enhance the user experience.
+When it comes to web development, performance is one of the critical elements that influence the success of an application.
+Developers focus on improving response times and overall speed to enhance the user experience.
 
-When a user visits a website or interacts with a web application, various resources such as images, scripts, and database queries are requested from the server. Retrieving these resources can sometimes be time-consuming, especially if they require complex processing or querying a database.
+When a user visits a website or interacts with a web application, various resources such as images, scripts, and database queries are requested from the server.
+Retrieving these resources can sometimes be time-consuming, especially if they require complex processing or querying a database.
 
-To speed up this process and improve overall performance, developers implement caching mechanisms. When data is first requested, it's stored in a cache. Then, when subsequent requests for the same data are made, the application can retrieve it from the cache instead of fetching it from the original source. This reduces the time it takes to serve the content to the user because accessing data from the cache is typically much faster than retrieving it from the original source.
+To speed up this process and improve overall performance, developers implement caching mechanisms.
+When data is first requested, it's stored in a cache.
+Then, when subsequent requests for the same data are made, the application can retrieve it from the cache instead of fetching it from the original source.
+This reduces the time it takes to serve the content to the user because accessing data from the cache is typically much faster than retrieving it from the original source.
 
 > This article is a follow-up to the [previous article](https://www.dotkernel.com/how-to/doctrine-cache-in-mezzio-and-dotkernel/) where we tackled the caching topic.
 
@@ -31,30 +37,32 @@ In this article our focus will be on enabling the [dot-cache](https://packagist.
 
 Run the following command in your project directory:
 
-```
+```bash
 composer require dotkernel/dot-cache
 ```
 
-After installing, add the `DotCacheConfigProvider::class` class to your configuration aggregate (config/config.php).
-
-Before we continue with the configuration process we need to know a few things about how and where the data is stored.
-
-The [dotkernel/dot-cache](https://packagist.org/packages/dotkernel/dot-cache) component is a wrapper that sits on top of [symfony/cache](https://packagist.org/packages/symfony/cache). It currently supports two adapters and can store data in two distinct locations:
+After installing, add the `DotCacheConfigProvider::class` class to your configuration aggregate (config/config.php).
+Before continuing with the configuration process, it helps to know a few things about how and where the data is stored.
+The [dotkernel/dot-cache](https://packagist.org/packages/dotkernel/dot-cache) component is a wrapper that sits on top of [symfony/cache](https://packagist.org/packages/symfony/cache).
+It currently supports two adapters and can store data in two distinct locations:
 
-1. **array** - stores data in-memory
-2. **filesystem** - stores data on local disk files
+- array - stores data in-memory
+- filesystem - stores data on local disk files
 
-1. Storing data in-memory is the fastest and sometimes the cheapest caching mechanism, but it also comes with down-sides. Storing everything in the RAM memory is not the best idea when your application is running on a low memory system. In this case you should consider using the **filesystem** mechanism.
+1. Storing data in-memory is the fastest and sometimes the cheapest caching mechanism, but it also comes with down-sides.
+Storing everything in RAM memory is not the best idea when your application is running on a low memory system.
+In this case you should consider using the filesystem mechanism.
 
-2. The second caching mechanism involves storing data into files on the local disk, known as the **filesystem** option. While this option may be slightly slower than the first one, it provides a more persistent storage solution.
+2. The second caching mechanism involves storing data into files on the local disk, known as the filesystem option.
+While this option may be slightly slower than the first one, it provides a more persistent storage solution.
 
-**Feel free to explore and use other adapters from [symfony/cache](https://packagist.org/packages/symfony/cache)** **by checking the [official documentation](https://symfony.com/doc/current/components/cache.html#advanced-usage).**
+Feel free to explore and use other adapters from [symfony/cache](https://packagist.org/packages/symfony/cache) by checking the [official documentation](https://symfony.com/doc/current/components/cache.html#advanced-usage).
 
 ## Configuration
 
-In `configautoloaddoctrine.global.php`, in the `doctrine.configuration.orm_default` key add the following entry:
+In `config/autoload/doctrine.global.php`, in the `doctrine.configuration.orm_default` key add the following entry:
 
-```
+```php
 'result_cache'       => 'filesystem',
 'metadata_cache'     => 'filesystem',
 'query_cache'        => 'filesystem',
@@ -63,64 +71,74 @@ In `configautoloaddoctrine.global.php`, in the `doctrine.configuration.orm_defa
 ],
 ```
 
-Next, under the `doctrine` key add the following items:
+Next, under the `doctrine` key add the following items:
 
-```
+```php
 'cache' => ,
     'filesystem' => ,
 ],
 ```
 
-The result is that the metadata and query cache will be stored in the `data/cache/doctrine` folder and the hydration cache will be stored in-memory.
-
-Each system is unique, requiring customized configurations. Make sure to identify the specific configuration requirements for your application.
-
-**Doctrine cache is divided into 4 different types: **
+The result is that the metadata and query cache will be stored in the `data/cache/doctrine` folder and the hydration cache will be stored in-memory.
+Each system is unique, requiring customized configurations.
+Make sure to identify the specific configuration requirements for your application.
+Doctrine cache is divided into 4 different types:
 
 - `result_cache`
 - `metadata_cache`
 - `query_cache`
 - `hydration_cache`
 
-### **Result cache**
+### Result Cache
 
 The result cache can be used to store the results of your queries, enabling Doctrine to avoid querying the database or hydrating the data again after the initial retrieval.
 
- 
+### Metadata Cache
 
-### **Metadata cache**
+Parsing your class metadata on every request is inefficient.
+Instead, it's advisable to cache this information using one of the available cache adapters.
 
-Parsing your class metadata on every request is inefficient. Instead, it's advisable to cache this information using one of the available cache adapters.
+### Query Cache
 
- 
+In a production environment, it's strongly recommended to cache the resulting DQL query into its SQL equivalent.
+Since the query doesn't change unless the DQL query itself changes, it's unnecessary to parse it multiple times.
 
-### **Query cache**
+### Hydration Cache
 
-In a production environment, it's strongly recommended to cache the resulted DQL query into its SQL equivalent. Since the query doesn't change unless the DQL query itself changes, it's unnecessary to parse it multiple times.
+Doctrine hydration cache is a feature that stores the results of data hydration, which is the process of converting raw database data into usable objects or arrays.
+By caching these results, it avoids repeating the hydration process for repeated queries, improving performance.
 
-### **Hydration cache**
+## How to Use
 
-Doctrine hydration cache is a feature that stores the results of data hydration, which is the process of converting raw database data into usable objects or arrays. By caching these results, it avoids repeating the hydration process for repeated queries, improving performance.
-
-## How to use
-
-To enable caching for entities, need to add the  `#` attribute like in the following example:
+To enable caching for entities, you need to add the `#` attribute like in the following example:
 
-```
-###class Admin extends AbstractEntity implements AdminInterface{}
+```php
+#
+#
+#
+class Admin extends AbstractEntity implements AdminInterface
+{
+}
 ```
 
 For further details about the cache mode please refer to the [official documentation](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/second-level-cache.html).
-
-When querying data, you can have Doctrine cache your results. You do this by calling the `setCacheable` method on the query builder.
-
-```
-$this->getQueryBuilder()     ->select('admin')     ->from(Admin::class, 'admin')     ->setCacheable(true)     ->getQuery()     ->getResult();
+When querying data, you can have Doctrine cache your results.
+You do this by calling the `setCacheable` method on the query builder.
+
+```php
+$this->getQueryBuilder()
+     ->select('admin')
+     ->from(Admin::class, 'admin')
+     ->setCacheable(true)
+     ->getQuery()
+     ->getResult();
 ```
 
-Caching is not limited to entities alone. Objects can be cached too. Check the [basic cache usage](https://symfony.com/doc/current/components/cache.html#basic-usage-psr-6) for this purpose.
-
-In conclusion, cache plays a vital role in optimizing system performance and improving user experience by storing frequently accessed data. As technology continues to evolve, caching mechanisms will remain an integral part of modern computing architectures, driving faster access to data and smoother user interactions across various digital platforms.
+Caching is not limited to entities alone.
+Objects can be cached too.
+Check the [basic cache usage](https://symfony.com/doc/current/components/cache.html#basic-usage-psr-6) for this purpose.
+In conclusion, cache plays a vital role in optimizing system performance and improving user experience by storing frequently accessed data.
+As technology continues to evolve, caching mechanisms will remain an integral part of modern computing architectures, driving faster access to data and smoother user interactions across various digital platforms.
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel/doctrine-enum-implementation-in-dotkernel.md b/public/md-articles/dotkernel/doctrine-enum-implementation-in-dotkernel.md
index c794116f..84a6f134 100644
--- a/public/md-articles/dotkernel/doctrine-enum-implementation-in-dotkernel.md
+++ b/public/md-articles/dotkernel/doctrine-enum-implementation-in-dotkernel.md
@@ -11,21 +11,19 @@ language: "en"
 # Doctrine enum implementation in Dotkernel
 
 ## TL;DR
+
 Doctrine ORM 3.2.0 added EnumType columns, building on the enum type introduced in PHP 8.1, and Dotkernel now implements this on both the PHP and database sides.
 The article contrasts Dotkernel's old string-based flag columns (like `User->Status`) with a new setup that uses custom PHP enums paired with a DBAL type extending `AbstractEnumType`.
 The new approach creates an explicit, enforced link between the PHP code and the database column values, at the cost of needing to update both sides whenever the value set changes.
 
-The update of `doctrine/orm` to version 3.2.0 saw the introduction of **EnumType** columns. The enum type was introduced in **PHP 8.1**. This new data type is now implemented in Dotkernel, on both the PHP side and the database side.
-
-Below we will discuss some technical aspects behind this update. You can review the full update in [this Dotkernel API Pull Request](https://github.com/dotkernel/api/pull/339/files).
+## Doctrine's Approach
 
-## Doctrine's approach
+The update introduces the detection of `enumType` and `options.values` from a property with `type: Types::ENUM`.
+[This PR](https://github.com/doctrine/orm/pull/11666) discusses the update and links to several older relevant issues.
 
-The update introduces the detection of `enumType` and `options.values` from a property with `type: Types::ENUM`. [This PR](https://github.com/doctrine/orm/pull/11666) discusses the update and links to several older relevant issues.
+### Old Setup
 
-### Old setup
-
-```
+```php
 #[Entity]
 class Card
 {
@@ -43,9 +41,9 @@ class Card
 }
 ```
 
-### New setup
+### New Setup
 
-```
+```php
 #[Entity]
 class Card
 {
@@ -59,21 +57,27 @@ class Card
 }
 ```
 
-> Note that the type `Types::ENUM` part is still required if we want to have an actual `enum` column in MariaDB. We still default to `Types::STRING` or `TYPES::INTEGER` for columns types with a PHP enum as this is the more portable solution and the safer default.
+Note that the type `Types::ENUM` part is still required if we want to have an actual `enum` column in MySQL/MariaDB.
+We still default to `Types::STRING` or `Types::INTEGER` for column types with a PHP enum, as this is the more portable solution and the safer default.
 
-## Dotkernel's approach
+## Dotkernel's Approach
 
-### Old setup
+### Old Setup
 
-Dotkernel uses flags for columns like `User->Status`, but we resorted to the simpler `string` type. The obvious disadvantage is that you can't definitively enforce a set of values for a given column. Sure, the PHP can be set up to only use the agrred upon set of values, but the database is independent from it. If you edit a value manually in the database, any string is accepted.
+Dotkernel uses flags for columns like `User->Status`, but we resorted to the simpler `string` type.
+The obvious disadvantage is that you can't definitively enforce a set of values for a given column.
+Sure, the PHP can be set up to only use the agreed-upon set of values, but the database is independent from it.
+If you edit a value manually in the database, any string is accepted.
 
-The issue is the same on the side of the PHP code. If the developer adds a value with a typo, it's supported, but will not work as intended.
+The issue is the same on the side of the PHP code.
+If the developer adds a value with a typo, it's supported, but will not work as intended.
 
-The only advantage this setup has is the ability to easily add more values in the value set. This may be seen as a feature, but it invites bugs in the execution.
+The only advantage this setup has is the ability to easily add more values in the value set.
+This may be seen as a feature, but it invites bugs in the execution.
 
 Our old implementation defined the values like below, for the `User` entity.
 
-```
+```php
 public const STATUS_PENDING = 'pending';
 public const STATUS_ACTIVE  = 'active';
 public const STATUSES       = [
@@ -84,14 +88,14 @@ public const STATUSES       = [
 
 The column for the ORM was defined like this, as a simple string, with `pending` as its default value:
 
-```
+```php
 #[ORM\Column(name: "status", type: "string", length: 20)]
 protected string $status = self::STATUS_PENDING;
 ```
 
 Obviously, the `getStatus` and `setStatus` also work with strings:
 
-```
+```php
 public function getStatus(): string
 {
     return $this->status;
@@ -103,19 +107,20 @@ public function setStatus(string $status): self
 }
 ```
 
-### New setup
+### New Setup
 
-Thanks to the update of `doctrine/orm` to version 3.2.0, Dotkernel can now have a proper link between the PHP code and database values. Now the link between the PHP code and the database is explicit and enforced.
+Thanks to the update of `doctrine/orm` to version 3.2.0, Dotkernel can now have a proper link between the PHP code and database values.
+Now the link between the PHP code and the database is explicit and enforced.
 
-> Any update to the value set must be on both the PHP code and the database.
+Any update to the value set must be on both the PHP code and the database.
 
 Let's review how the update affects the `User` entity.
 
-> In the next example, we show how to implement a value set using a custom enum.
+In the next example, we show how to implement a value set using a custom enum.
 
 First, we define our custom value set in `src/User/src/Enum/UserStatusEnum.php`.
 
-```
+```php
 namespace Api\User\Enum;
 
 enum UserStatusEnum: string
@@ -127,9 +132,9 @@ enum UserStatusEnum: string
 
 We need to create `src/User/src/DBAL/Types/UserStatusEnumType.php` to process the new values for the `status` column.
 
-> `AbstractEnumType` must be extended by any future custom enum type.
+`AbstractEnumType` must be extended by any future custom enum type.
 
-```
+```php
 namespace Api\User\DBAL\Types;
 
 use Api\App\DBAL\Types\AbstractEnumType;
@@ -151,11 +156,11 @@ class UserStatusEnumType extends AbstractEnumType
 }
 ```
 
-> If you create your own enum types, make sure to update the `NAME` constant and the value returned by `getEnumClass`.
+If you create your own enum types, make sure to update the `NAME` constant and the value returned by `getEnumClass`.
 
 Let's register the custom type in `config/autoload/doctrine.global.php` under the `types` key:
 
-```
+```php
 'types'         => [
 [...]
     UserStatusEnumType::NAME => UserStatusEnumType::class,
@@ -165,7 +170,7 @@ Let's register the custom type in `config/autoload/doctrine.global.php` under th
 
 The filtering is updated in `src/User/src/InputFilter/Input/StatusInput.php`:
 
-```
+```php
 $this->getFilterChain()
     ->attachByName(StringTrim::class)
     ->attachByName(StripTags::class)
@@ -182,14 +187,14 @@ The above ensures that the new `UserStatusEnum` class is used for the `status` c
 
 The `User` entity uses the new `UserStatusEnum` class.
 
-```
+```php
 #[ORM\Column(type: 'user_status_enum', options: ['default' => UserStatusEnum::Pending])]
 protected UserStatusEnum $status = UserStatusEnum::Pending;
 ```
 
 The `status` getter and setter are also updated:
 
-```
+```php
 public function getStatus(): UserStatusEnum
 {
     return $this->status;
@@ -201,9 +206,10 @@ public function setStatus(UserStatusEnum $status): self
 }
 ```
 
-Dotkernel checks the user status during login in `src/User/src/Repository/UserRepository.php`. If the user is not activated, the login is rejected.
+Dotkernel checks the user status during login in `src/User/src/Repository/UserRepository.php`.
+If the user is not activated, the login is rejected.
 
-```
+```php
 if ($clientEntity->getName() === 'frontend' && $result['status'] !== UserStatusEnum::Active) {
     throw new OAuthServerException(Message::USER_NOT_ACTIVATED, 6, 'inactive_user', 401);
 }
@@ -211,7 +217,7 @@ if ($clientEntity->getName() === 'frontend' && $result['status'] !== UserStatusE
 
 A new user is created using the `enum` type and `pending` as the default.
 
-```
+```php
 $user = (new User())
     ->setDetail($detail)
     ->setIdentity($data['identity'])
@@ -245,19 +251,14 @@ new setup: status ENUM(\'active\', \'pending\') DEFAULT \'pending\' NOT NULL
 
 ## Conclusions
 
-The old setup used in the Dotkernel applications worked fine, but the limitations were clear as day. There was:
+The old setup used in the Dotkernel applications worked fine, but the limitations were clear as day.
+There was:
 
 - No enforcement of the value set.
 - No link between the PHP code and the database.
 
 The new setup solves both issues, ensuring more consistent flag management for your classes.
 
-## Relevant links
-
-- [Dotkernel API Pull Request](https://github.com/dotkernel/api/pull/339/files)
-- [Doctrine Pull Request](https://github.com/doctrine/orm/pull/11666)
-- [PHP Enumerations](https://www.php.net/manual/en/language.enumerations.overview.php)
-
 ## FAQ
 
 **Q: What update triggered this change to Dotkernel's enum handling?**
@@ -273,7 +274,13 @@ A: It made it easy to add more values to the value set, though the article notes
 A: A PHP enum class (like UserStatusEnum) plus a DBAL type class extending AbstractEnumType, which must define a NAME constant and a getEnumClass() method; the new type is then registered under the types key in config/autoload/doctrine.global.php.
 
 **Q: Does Types::ENUM still fall back to a string or integer database column?**
-A: The article notes that Doctrine still defaults to Types::STRING or Types::INTEGER for columns backed by a PHP enum, as this is considered the more portable and safer default; Types::ENUM is required if you want an actual enum column in MariaDB.
+A: The article notes that Doctrine still defaults to Types::STRING or Types::INTEGER for columns backed by a PHP enum, as this is considered the more portable and safer default; Types::ENUM is required if you want an actual enum column in MySQL/MariaDB.
 
 **Q: What must happen when the value set of an enum changes under the new setup?**
 A: Any update to the value set must be made on both the PHP code and the database, since the new setup creates an explicit, enforced link between them.
+
+## Resources
+
+- [Dotkernel API Pull Request](https://github.com/dotkernel/api/pull/339/files)
+- [Doctrine Pull Request](https://github.com/doctrine/orm/pull/11666)
+- [PHP Enumerations](https://www.php.net/manual/en/language.enumerations.overview.php)
diff --git a/public/md-articles/dotkernel/dotboost-technologies-products-and-services-north-american-relaunch.md b/public/md-articles/dotkernel/dotboost-technologies-products-and-services-north-american-relaunch.md
index 1e0ad2fc..5db3060a 100644
--- a/public/md-articles/dotkernel/dotboost-technologies-products-and-services-north-american-relaunch.md
+++ b/public/md-articles/dotkernel/dotboost-technologies-products-and-services-north-american-relaunch.md
@@ -11,19 +11,28 @@ language: "en"
 # DotBoost Technologies : Products and Services North American Relaunch
 
 ## TL;DR
+
 Dotboost announces its North American relaunch, aimed at better serving clients in Canada and the US.
 The relaunch centers on the source release of its in-house Dotkernel framework, along with expanded business IT integration and clearer consulting services.
 Founded in 2005, Dotboost describes itself as treating clients as strategic partners rather than as a typical IT vendor.
 
-**A new style and advanced approach to accompany the Dotkernel source release**
+## The North American Relaunch
+
+A new style and advanced approach to accompany the Dotkernel source release.
+
+Dotboost is pleased to announce our North American Relaunch.
+This new phase comes as a result of dedicated research and analysis on how to best serve clients in Canada and the US.
 
-Dotboost is pleased to announce our North American Relaunch. This new phase comes as a result of dedicated research and analysis on how to best serve clients in Canada and the US.
+At the heart of our relaunch is the source release for our exclusive inhouse developed Dotkernel framework.
+We have also added business IT integration and increased the clarity to our existing consulting services.
 
-At the heart of our relaunch is the source release for our exclusive inhouse developed Dotkernel framework. We have also added business IT integration and increased the clarity to our existing consulting services.
+## The Dotboost Approach
 
-We're not your average IT organization; we view our customers as strategic partners. This paradigm allows us to take a comprehensive approach towards creating solutions and gain the competitive advantage.
+We're not your average IT organization; we view our customers as strategic partners.
+This paradigm allows us to take a comprehensive approach towards creating solutions and gain the competitive advantage.
 
-Founded in 2005, the Dotboost process can incorporate anywhere into your project's life-cycle including concept development, architecture and design, development and integration, and implementation and support. We use time and distance to our advantage, pushing competitive boundaries and staking our place as a globally efficient organization.
+Founded in 2005, the Dotboost process can incorporate anywhere into your project's life-cycle including concept development, architecture and design, development and integration, and implementation and support.
+We use time and distance to our advantage, pushing competitive boundaries and staking our place as a globally efficient organization.
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel/dotkernel-1-2-0-release.md b/public/md-articles/dotkernel/dotkernel-1-2-0-release.md
index e135e983..85d3f2e9 100644
--- a/public/md-articles/dotkernel/dotkernel-1-2-0-release.md
+++ b/public/md-articles/dotkernel/dotkernel-1-2-0-release.md
@@ -11,27 +11,39 @@ language: "en"
 # Dotkernel 1.2.0 release
 
 ## TL;DR
+
 Dotkernel 1.2.0 has been released, bringing changes since the previous 1.1.2 release.
 The database tables were renamed and restructured to follow database naming conventions, and configuration for each "dots" (submodule) now lives in XML files instead of being hard-coded in PHP.
 The release also adds new library classes (Dot_Geoip, Dot_Seo), updates existing ones (Dot_Curl, Dot_Session), and confirms that all SQL queries are written as prepared statements.
 
-Finally we reached Dotkernel 1.2.0 milestone.
+## Database Naming Conventions
+
+On database, we changed the names and structure of tables to respect database naming convention.
+See [http://www.dotkernel.com/dotkernel/dotkernel-database-naming-conventions-for-mysql/](http://www.dotkernel.com/dotkernel/dotkernel-database-naming-conventions-for-mysql/) for details.
+
+## The "Dots" Concept
 
-Since the previous released 1.1.2, some changes have been made.
+A new word came into our Dotkernel discussions: dots.
+We use this term when talking about a submodule and all its component files.
+For example, "user" is a submodule of the frontend module.
+Note that one dots can be part of multiple modules (for example, "user" dots belong to both the frontend and admin module).
+For each dots, the configuration values have been added to XML files which are stored in the configs/dots folder.
+In the previous versions, these values were hard-coded in the PHP files.
 
-- On database, we changed the names and structure of tables to respect database naming convention. [*http://www.dotkernel.com/dotkernel/dotkernel-database-naming-conventions-for-mysql/*](../dotkernel/dotkernel-database-naming-conventions-for-mysql/)
+Another change made in the configs folder is resource.xml, which contains the configuration values for the controllers of each module.
 
-- A new word came into our Dotkernel discussions: ***dots.*** We use this term when talking about a submodule and all its component files. For example, *“user”* is a submodule of *frontend* module. Note that one dots can be part of multiple modules. (For example, *“user”* dots belong to *frontend* and *admin* module). For each dots, the configurations values have been added to xml files which are stored in *configs/dots* folder. In the preview versions, this values where hard-coded in the php files.
+To be easier to start an application from Dotkernel, in the admin module, there are now the following dots: admin, user and system.
 
-- Another change made in *configs* folder is *resource.xml*, which contains the configuration values for the controllers of each module.
+## Library Class Updates
 
-To be easier to start an application from Dotkernel, in admin module, there are now the following dots:  admin, user and system.
+New library classes have been implemented: Dot_Geoip and Dot_Seo, and some of the existing ones have been updated: Dot_Curl and Dot_Session (each module has its own session).
 
-New library classes have been implemented: Dot_Geoip and Dot_Seo, and some of the existing ones have been updated: Dot_Curl and Dot_Session (each module has his own session).
+## SQL Prepared Statements
 
-In Dotkernel, all SQL queries are written as prepared statements.  We strongly encourage this  practice: *[http://www.dotkernel.com/php-development/protection-against-sql-injection-using-pdo-and-zend-framework/](../php-development/protection-against-sql-injection-using-pdo-and-zend-framework/)*
+In Dotkernel, all SQL queries are written as prepared statements.
+We strongly encourage this practice: [http://www.dotkernel.com/php-development/protection-against-sql-injection-using-pdo-and-zend-framework/](http://www.dotkernel.com/php-development/protection-against-sql-injection-using-pdo-and-zend-framework/)
 
-For more details, see  [ChangeLog 1.2.0](http://www.dotkernel.com/changelog/1-2-0/)
+For more details, see [ChangeLog 1.2.0](http://www.dotkernel.com/changelog/1-2-0/).
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel/dotkernel-1-2-2-release.md b/public/md-articles/dotkernel/dotkernel-1-2-2-release.md
index 53290e96..95c3fa76 100644
--- a/public/md-articles/dotkernel/dotkernel-1-2-2-release.md
+++ b/public/md-articles/dotkernel/dotkernel-1-2-2-release.md
@@ -11,30 +11,43 @@ language: "en"
 # Dotkernel 1.2.2 release
 
 ## TL;DR
+
 Dotkernel 1.2.2 is a bug-fix release that closes five tracked issues.
 Because one of the fixes updated the copyright line, every PHP file in the codebase changed, so the full release or the incremental upgrade package is needed.
 
-Yesterday, we released **Dotkernel 1.2.2**. It contains some bug fixes:
+## Bug fixes in 1.2.2
+
+- **31** - captcha errors try/catch
+- **32** - pagination issue
+- **33** - admin wrong link
+- **34** - Acunetix scan results from July 24th (notices and one fatal error)
+- **35** - update copyright line in files
 
-- [31](http://www.dotkernel.net/view.php?id=31) – captcha errors try catch
-- [32](http://www.dotkernel.net/view.php?id=32) – pagination issue
-- [33](http://www.dotkernel.net/view.php?id=33) – Admin wrong link
-- [34](http://www.dotkernel.net/view.php?id=34) – Acunetix results July 24th ( notices and one fatal error)
-- [35](http://www.dotkernel.net/view.php?id=35) – update copyright line in files
+**Note:** because of bug 35, all PHP files changed in this release.
 
-For more details see [ChangeLog 1.2.2](../changelog/1-2-2/). To get only the changed files from 1.2.1 to 1.2.2, download the [upgrade](../download/?did=17) file
+## Upgrading
 
-**Note***: because of the Bug 35, all php files have changed. To see what else has changed, check the [Dotkernel Tracker](http://www.dotkernel.net/) or the [Dotkernel WebSVN](http://websvn.dotkernel.net/listing.php?repname=Dotkernel+ver.+1) .
+To get only the changed files from 1.2.1 to 1.2.2, download the upgrade package (linked in the post) instead of the full distribution.
+Full details are available in the ChangeLog 1.2.2, and further changes can be tracked on the Dotkernel Tracker or Dotkernel WebSVN.
 
-*P.S.* On July 22, 2010 we released *Dotkernel 1.2.1.* You can check the [ChangeLog 1.2.1](../changelog/1-2-1/) or download [the upgrade 1.2.1](../download/?did=14) zip file.
+Note also that Dotkernel 1.2.1 had been released a few days earlier, on July 22, 2010, with its own ChangeLog and upgrade package.
 
 ## FAQ
 
 **Q: What does the Dotkernel 1.2.2 release include?**
-A: Dotkernel 1.2.2 is a bug-fix release that closes five issues: captcha error handling (try/catch), a pagination issue, a wrong admin link, notices and a fatal error found by an Acunetix scan, and an update to the copyright line in files.
+A: It's a bug-fix release that closes five issues: captcha error handling (try/catch), a pagination issue, a wrong admin link, notices and a fatal error found by an Acunetix scan, and an update to the copyright line in files.
 
 **Q: Why did all PHP files change in the 1.2.2 release?**
 A: Because of the fix for bug 35, which updated the copyright line, every PHP file in the codebase was touched, which is why the note in the post warns that all PHP files have changed.
 
 **Q: How can I upgrade from a previous version to 1.2.2?**
 A: You can download just the changed files from 1.2.1 to 1.2.2 using the upgrade package linked in the post, or check the ChangeLog 1.2.2 for full details of what changed.
+
+## Resources
+
+- ChangeLog 1.2.2 (linked in the original post as `../changelog/1-2-2/`)
+- Upgrade package for 1.2.2 (linked in the original post as `../download/?did=17`)
+- Dotkernel Tracker: http://www.dotkernel.net/
+- Dotkernel WebSVN: http://websvn.dotkernel.net/listing.php?repname=Dotkernel+ver.+1
+- ChangeLog 1.2.1 (linked in the original post as `../changelog/1-2-1/`)
+- Upgrade package for 1.2.1 (linked in the original post as `../download/?did=14`)
diff --git a/public/md-articles/dotkernel/dotkernel-1-3-0-release.md b/public/md-articles/dotkernel/dotkernel-1-3-0-release.md
index c90ce5ec..10389c78 100644
--- a/public/md-articles/dotkernel/dotkernel-1-3-0-release.md
+++ b/public/md-articles/dotkernel/dotkernel-1-3-0-release.md
@@ -11,28 +11,37 @@ language: "en"
 # Dotkernel 1.3.0 release
 
 ## TL;DR
+
 Dotkernel 1.3.0 brings a switchable admin skin, a way to protect member-only pages, a rename of Dot_Sessions, and a reorganization of resource.xml into route.xml and dots.xml.
 Because of that XML reorganization, 1.3.0 is not backward compatible with earlier versions.
 
-[Dotkernel 1.3.0](../download/?did=23) is released at last. It contains important changes and new features.
+## Highlights
+
+### Admin skin switcher
+
+The admin skin can now be customized. Several ready-made skins are available: blue, brown, gray, and green.
+Set the skin by changing the `settings.admin.skin` value (e.g. `settings.admin.skin = green`).
 
-- [64](http://www.dotkernel.net/view.php?id=64): **[Feature]** Skin switcher in admin - closed.
+### Protecting member-only links
 
-The admin skin can be customized. There are several readymade skins like: *blue*, *brown*, *gray* and *green*. To set the admin skin, change the value of *settings.admin.skin* from application (e.g. *settings.admin.skin = green*).
+To protect a link so only logged-in members can access it, add this line in the controller file above the code that should require login:
 
-- [76](http://www.dotkernel.net/view.php?id=76): **[Bugs]** Want-Url in frontend - closed.
+```php
+Dot_Auth::checkIdentity();
+```
 
-To protect a link that is accessible by members only, add this line in the controller file to protect what is below it: *Dot_Auth::checkIdentity();*
+### XML reorganization
 
-- [77](http://www.dotkernel.net/view.php?id=77): **[Bugs]** Dot_Sessions / rename - closed. - [70](http://www.dotkernel.net/view.php?id=70): **[Bugs]** Menu issue in Admin and frontend - closed. - [73](http://www.dotkernel.net/view.php?id=73): **[Bugs]** Naming consistency Upper-lower case in url - closed. - [71](http://www.dotkernel.net/view.php?id=71): **[Bugs]** XSS forgot password - closed. - [72](http://www.dotkernel.net/view.php?id=72): **[Bugs]** scan result Oct 12th - closed. - [63](http://www.dotkernel.net/view.php?id=63): **[Bugs]** Scan results Oct 1, 2010 on 1.3.0 RC - closed. - [69](http://www.dotkernel.net/view.php?id=69): **[Bugs]** reorganization of XMl files - closed.
+Some XML files from the configs folder were changed. `resource.xml` was deleted and its content was split between two new files, `route.xml` and `dots.xml`.
 
-Some xml files from configs folder have been changed to encompass the current needs of Dotkernel. *resource.xml* has been deleted and its content split between *route.xml* and *dots.xml*. Check the manual to find more about [route.xml](../docs/router-xml/) and [dots.xml](../docs/dots-xml/)
+### Other closed issues
 
-- [67](http://www.dotkernel.net/view.php?id=67): **[Bugs]** Security Issue / test controller - closed. - [68](http://www.dotkernel.net/view.php?id=68): **[Bugs]** The canonical URL isn't escaped - closed. - [66](http://www.dotkernel.net/view.php?id=66): **[Bugs]** Blank line at the beginning of every file in the frontend - closed. - [60](http://www.dotkernel.net/view.php?id=60): **[Bugs]** 1.3.0 as Release Candidate Friday Oct 1st - closed. - [62](http://www.dotkernel.net/view.php?id=62): **[Bugs]** Admin text box class dojo - closed. - [55](http://www.dotkernel.net/view.php?id=55): **[Bugs]** geoIP extension: record by name + list in dashboard admin GEOIP version and build - closed. - [59](http://www.dotkernel.net/view.php?id=59): **[Bugs]** Admin listings # - closed. - [61](http://www.dotkernel.net/view.php?id=61): **[Bugs]** Admin Add Transporter not working - closed. - [58](http://www.dotkernel.net/view.php?id=58): **[Bugs]** Admin : list stuff, div float - closed. - [57](http://www.dotkernel.net/view.php?id=57): **[Bugs]** OS name on admin/on mouse over - closed. - [53](http://www.dotkernel.net/view.php?id=53): **[Bugs]** drop-down list in admin/user logins - closed. - [52](http://www.dotkernel.net/view.php?id=52): **[Bugs]** Admin hide debug bar in Login page - closed.
+The release also closed a number of other tracked issues, covering: the Dot_Sessions rename, menu issues in Admin and frontend, URL casing consistency, an XSS issue in the forgot-password flow, several security scan results, admin listing/UI fixes, a GeoIP extension listing feature, and formatting cleanup (blank lines, brace placement) across the frontend files.
 
-For more details see [ChangeLog 1.3.0](../changelog/1-3-0/).
+## Compatibility note
 
-**Note***: because of the bug [69](http://www.dotkernel.net/view.php?id=69), this release is not compatible with the previous versions. To see what else has changed, check [Dotkernel Tracker](http://www.dotkernel.net/) or [Dotkernel WebSVN](http://websvn.dotkernel.net/listing.php?repname=Dotkernel).
+Because of the XML file reorganization, this release is **not compatible** with previous versions.
+Further details on what changed are available on the Dotkernel Tracker or Dotkernel WebSVN.
 
 ## FAQ
 
@@ -47,3 +56,12 @@ A: resource.xml was deleted and its content split between two new files, route.x
 
 **Q: Is Dotkernel 1.3.0 backward compatible with earlier versions?**
 A: No. Because of the XML file reorganization (bug 69), 1.3.0 is not compatible with previous versions.
+
+## Resources
+
+- Dotkernel 1.3.0 download (linked in the original post as `../download/?did=23`)
+- ChangeLog 1.3.0 (linked in the original post as `../changelog/1-3-0/`)
+- route.xml documentation (linked in the original post as `../docs/router-xml/`)
+- dots.xml documentation (linked in the original post as `../docs/dots-xml/`)
+- Dotkernel Tracker: http://www.dotkernel.net/
+- Dotkernel WebSVN: http://websvn.dotkernel.net/listing.php?repname=Dotkernel
diff --git a/public/md-articles/dotkernel/dotkernel-1-3-2-release.md b/public/md-articles/dotkernel/dotkernel-1-3-2-release.md
index 3383a78c..77aca70a 100644
--- a/public/md-articles/dotkernel/dotkernel-1-3-2-release.md
+++ b/public/md-articles/dotkernel/dotkernel-1-3-2-release.md
@@ -11,30 +11,29 @@ language: "en"
 # Dotkernel 1.3.2 release
 
 ## TL;DR
-Released just before the winter holidays, Dotkernel 1.3.2 is mainly a maintenance release: it contains many bug fixes, some refactoring, and a few minor features.
 
-Before the winter holiday we came with a new release: [Dotkernel 1.3.2](http://www.dotkernel.com/download/?did=27) It contains many bug fixes, some refactoring and a few minor features.
+Released just before the winter holidays, Dotkernel 1.3.2 is mainly a maintenance release: it contains many bug fixes, some refactoring, and a few minor features.
 
-Bugs fixes:
+## Bug fixes
 
-- [0000111](http://www.dotkernel.net/view.php?id=111): **[Bugs]** Css phpinfo page admin
-- [0000115](http://www.dotkernel.net/view.php?id=115): **[Bugs]** warning in admin dashboard for file
-- [0000108](http://www.dotkernel.net/view.php?id=108): **[Bugs]** WUFRL cache in admin
-- [0000094](http://www.dotkernel.net/view.php?id=94): **[Bugs]** WURLF version
-- [0000112](http://www.dotkernel.net/view.php?id=112): **[Bugs]** Dot_Paginator Bug
-- [0000109](http://www.dotkernel.net/view.php?id=109): **[Bugs]** Zend Paginator double query ?
-- [0000089](http://www.dotkernel.net/view.php?id=89): **[Bugs]** Database naming convention
-- [0000097](http://www.dotkernel.net/view.php?id=97): **[Bugs]** Database normalisation/refactor
+- CSS issue on the admin phpinfo page
+- Warning in the admin dashboard for a file
+- WURFL cache issue in admin
+- WURFL version issue
+- Dot_Paginator bug
+- Zend Paginator double-query issue
+- Database naming convention issue
+- Database normalisation/refactor
 
-Minor features:
+## Minor features
 
-- [0000096](http://www.dotkernel.net/view.php?id=96): **[Feature]** validIP , class Dot_Kernel refactor
-- [0000099](http://www.dotkernel.net/view.php?id=99): **[Feature]** WURFL date and api version in admin
+- Refactor of validIP in the Dot_Kernel class
+- WURFL date and API version shown in admin
 
-Refactoring:
+## Refactoring
 
-- [0000110](http://www.dotkernel.net/view.php?id=110): **[REFACTOR]** Zend_Paginator
-- [0000107](http://www.dotkernel.net/view.php?id=107): **[REFACTOR]** Add a dojo dijit theme to Dotkernel
+- Zend_Paginator refactoring
+- Added a dojo dijit theme to Dotkernel
 
 ## FAQ
 
@@ -45,4 +44,9 @@ A: It's mainly a maintenance release, containing many bug fixes, some refactorin
 A: Fixes include a CSS issue on the admin phpinfo page, a warning in the admin dashboard, a WURFL cache issue and WURFL version issue in admin, a Dot_Paginator bug, a Zend Paginator double-query issue, and a database naming convention issue.
 
 **Q: What minor features and refactoring were included?**
-A: Minor features include a refactor of validIP in Dot_Kernel and showing the WURFL date and API version in admin. Refactoring covered Zend_Paginator and added a dojo dijit theme to Dotkernel.
+A: Minor features include a refactor of validIP in Dot_Kernel and showing the WURFL date and API version in admin.
+Refactoring covered Zend_Paginator and added a dojo dijit theme to Dotkernel.
+
+## Resources
+
+- Dotkernel 1.3.2 download: http://www.dotkernel.com/download/?did=27
diff --git a/public/md-articles/dotkernel/dotkernel-1-5-0-released.md b/public/md-articles/dotkernel/dotkernel-1-5-0-released.md
index 0a0f4c60..db62c3f6 100644
--- a/public/md-articles/dotkernel/dotkernel-1-5-0-released.md
+++ b/public/md-articles/dotkernel/dotkernel-1-5-0-released.md
@@ -11,42 +11,43 @@ language: "en"
 # Dotkernel 1.5.0 Released
 
 ## TL;DR
+
 After a longer wait than usual and around 250 commits, Dotkernel 1.5.0 was released, skipping 1.4 entirely due to the scale of changes.
 Highlights include switching from Dojo to jQuery, a redesigned admin and frontend, model inheritance through a new Dot_Model class, support for dashed controller names, and a reorganized Zend Registry.
 
-After a longer wait than usual, Dotkernel 1.5.0 was just released. Due to the large amount of changes and the long time spent in development, we chose to skip 1.4 and go straight to 1.5.0.
+## Why skip straight to 1.5.0?
 
-Here are a few of the many changes to Dotkernel in the latest release:
+Due to the large amount of changes and the long time spent in development, the team chose to skip 1.4 and go straight to 1.5.0.
 
 ## Highlights of 1.5.0
 
 ### Switched from Dojo to jQuery
 
-Starting with 1.5.0 we've [switched from using Dojo to jQuery](http://www.dotkernel.com/javascript/intro-to-jquery/). This doesn't mean you can't still use Dojo in your own projects, but only jQuery will be used and maintained in the Dotkernel distribution.
+Starting with 1.5.0, Dotkernel switched from using Dojo to jQuery.
+Dojo can still be used in your own projects, but only jQuery is used and maintained in the Dotkernel distribution itself.
 
 ### New designs
 
-We've redesigned the admin site, with new themes, and a dropdown menu, as well as a new and simpler design for the front-end.
+The admin site was redesigned, with new themes and a dropdown menu, along with a new and simpler design for the front-end.
 
 ### Model inheritance
 
-Up until now, there was a lot of code duplication in models. For example, in the user model, you might have a *getUserById* function in the admin as well as the frontend. When you've got more models and more modules, your project can start having a lot of copy-pasted code.
-
-To prevent this, we've introduced a *Dot_Model* class, and a way to define global models that are inherited in the admin and frontend. This way, you can have *User* class in the admin that only has methods specific to the admin module, a *User* class in the frontend that only has code specific for the frontend, and they both inherit the *Dot_Model_User* class which will have all the common code.
+Previously there was a lot of code duplication in models - for example, a `getUserById` function might exist separately in both the admin and frontend User models.
+To solve this, a `Dot_Model` class was introduced along with a way to define global models inherited by both admin and frontend.
+A `User` class in the admin only holds admin-specific methods, a `User` class in the frontend only holds frontend-specific methods, and both inherit a shared `Dot_Model_User` class containing the common code.
 
 ### Dashed controllers
 
-We've changed the way the controller name is parsed, so that you can have controller with multiple words, split with dashes, without breaking the coding standard (for example, *www.example.com/search-article* will call *SearchArticleController.php*)
+The way controller names are parsed was changed so that controllers with multiple words, split with dashes, work without breaking the coding standard.
+For example, `www.example.com/search-article` calls `SearchArticleController.php`.
 
 ### Zend Registry reorganization
 
-We've changed the structure of the registry, for more about this, please check [this blog post](http://www.dotkernel.com/dotkernel/zend-registry-usage-in-dotkernel/).
-
- 
+The structure of the registry was changed; more details are covered in a separate blog post on Zend Registry usage in Dotkernel.
 
-There have been about 250 commits in our SVN repository since the latest release, so we can't cover all changes in this blog post. Please [download Dotkernel 1.5.0](http://www.dotkernel.com/download/?did=33) try it out yourself and tell us what you think.
+## Scale of the release
 
- 
+There were about 250 commits in the SVN repository since the previous release, so the blog post could not cover every change.
 
 ## FAQ
 
@@ -54,13 +55,21 @@ There have been about 250 commits in our SVN repository since the latest release
 A: Because of the large amount of changes and the long time spent in development, the team chose to skip version 1.4 and go straight to 1.5.0.
 
 **Q: Did Dotkernel switch from Dojo to jQuery in 1.5.0?**
-A: Yes. Starting with 1.5.0, Dotkernel switched from Dojo to jQuery for its own distribution, though Dojo can still be used in your own projects.
+A: Yes.
+Starting with 1.5.0, Dotkernel switched from Dojo to jQuery for its own distribution, though Dojo can still be used in your own projects.
 
 **Q: What is Dot_Model and why was it introduced?**
-A: Dot_Model is a base class introduced to reduce code duplication between admin and frontend models. Both admin- and frontend-specific model classes (such as User) inherit from a shared Dot_Model_User class that holds the common code.
+A: Dot_Model is a base class introduced to reduce code duplication between admin and frontend models.
+Both admin- and frontend-specific model classes (such as User) inherit from a shared Dot_Model_User class that holds the common code.
 
 **Q: How does the "dashed controllers" feature work?**
 A: The controller name parsing was changed so a URL like www.example.com/search-article correctly calls SearchArticleController.php, allowing multi-word controller names split with dashes without breaking the coding standard.
 
 **Q: How much changed in the 1.5.0 release?**
 A: About 250 commits went into the SVN repository since the previous release, so the blog post only covers the highlights - the full Dotkernel 1.5.0 download is available to try out.
+
+## Resources
+
+- Intro to jQuery: http://www.dotkernel.com/javascript/intro-to-jquery/
+- Zend Registry usage in Dotkernel: http://www.dotkernel.com/dotkernel/zend-registry-usage-in-dotkernel/
+- Dotkernel 1.5.0 download: http://www.dotkernel.com/download/?did=33
diff --git a/public/md-articles/dotkernel/dotkernel-1-8-0-lts-released.md b/public/md-articles/dotkernel/dotkernel-1-8-0-lts-released.md
index 0d6174fa..ee76cf66 100644
--- a/public/md-articles/dotkernel/dotkernel-1-8-0-lts-released.md
+++ b/public/md-articles/dotkernel/dotkernel-1-8-0-lts-released.md
@@ -11,65 +11,56 @@ language: "en"
 # Dotkernel 1.8.0 LTS Released
 
 ## TL;DR
+
 Dotkernel 1.8.0 (LTS) was released with a new Plugin Architecture, a redesigned and mobile-friendly frontend, APC/File caching for faster response times, a new Dot_Request class, and multiple security and alerting improvements.
 Some features (WURFL integration, multiple SMTP transporters) were removed from core and made available as plugins instead.
 
-Dotkernel 1.8.0 (LTS) was just released.
-
-## **What is LTS?**
-
-Long-term support (LTS) is a type of special versions or editions of software designed to be supported for a longer than normal period. It is particularly applicable to open-source software projects. It contains many bug fixes, some refactoring and a few minor features. Find more details read [this article](http://www.dotkernel.com/long-term-support).
+## What is LTS?
 
- 
-
-Here are a few of the many changes to Dotkernel in the latest release:
+Long-term support (LTS) is a type of special version or edition of software designed to be supported for a longer than normal period.
+It's particularly applicable to open-source software projects.
+The 1.8.0 LTS release itself contains many bug fixes, some refactoring, and a few minor features.
 
 ## Highlights of 1.8.0 (LTS)
 
- 
-
 ### Plugin Architecture
 
-Starting with 1.8.0 we will start using Plugins to make the Dotkernel extending easier. We'll keep you up to date about how you create and use a plugin.
+Starting with 1.8.0, Dotkernel uses Plugins to make extending the framework easier.
 
 ### New design
 
-We've redesigned the admin module and the frontend module is now mobile-friendly, but you can still use the mobile module.
+The admin module was redesigned and the frontend module is now mobile-friendly, while the separate mobile module remains available.
 
-### Loads Faster
+### Loads faster
 
-The Dotkernel framework just got a big boost because it supports APC & File Caching within the framework, all the XML's and config files are cached in order to maximize response speed for more information about caching and how to cache your data see [this article](http://www.dotkernel.com/dotkernel/caching-in-dotkernel-using-zend-framework/).
+The framework now supports APC and File Caching, with all XML and config files cached in order to maximize response speed.
 
-### Easier Request Handling
+### Easier request handling
 
-We've added a new class, Dot_Request, which lets you have control over the request data before you use it, for example the variables $_SERVER, $_GET and $_POST are only used within controllers.
+A new class, `Dot_Request`, gives control over the request data before use - for example, so that `$_SERVER`, `$_GET`, and `$_POST` are only accessed from within controllers.
 
 ### Features added
 
-- API with Rate Limit - we've added a simple API with a single key authentification and a simple implementation of a rate limit (see /configs/application.ini - section params.api)
-- Cache System - Built on the Zend_Cache backends, provides caching within Dotkernel, but also in library, more details about this and how it works can be found [here](http://www.dotkernel.com/dotkernel/dotkernel-reserved-variable-names-for-caching/).
+- API with Rate Limit - a simple API with single-key authentication and a basic rate limit implementation (configurable in `/configs/application.ini`, section `params.api`)
+- Cache System - built on Zend_Cache backends, providing caching within Dotkernel and in library code
 
 ### Other changes
 
-- Removed WURFL integration, Dotkernel can detect wether you use a mobile device separately now, the WURFL Library can be added as a Plugin from now on
-- Removed multiple SMTP Transporter, it can be added as a plugin
-- Security scan in Admin Dashboard - you can now see which are the recommended settings (especially security related) for Dotkernel to work at it's best
-- Admin fail logins are no longer sent to the first admin, they are sent to all developers found in *devEmails* within *settings* table in the database
-- Alert System - Alerts can be sent to all the developers to notify them if something goes wrong, for more information about alerts read [this article](http://www.dotkernel.com/dotkernel/how-to-use-alerts-in-dotkernel/).
+- Removed WURFL integration - mobile device detection is now handled separately; WURFL can be added as a plugin
+- Removed support for multiple SMTP transporters - it can be added as a plugin
+- Security scan in the Admin Dashboard, showing recommended (especially security-related) settings
+- Admin failed-login notifications are now sent to all developers listed in `devEmails` (within the `settings` table), not just the first admin
+- Alert System - alerts can be sent to all developers to notify them if something goes wrong
 
-### Bug Fixes
+### Bug fixes
 
-- [0000289](http://dotkernel.net/view.php?id=289): **[Bugs]** seo.xml will cause error on same varname for two modules instead of overwriting
-- [0000249](http://dotkernel.net/view.php?id=249): **[Bugs]** email sent twice
-- [0000275](http://dotkernel.net/view.php?id=275): **[Bugs]** wrong unwritable warning on nginx
+- `seo.xml` caused an error when two modules used the same variable name instead of overwriting it
+- Emails were sent twice
+- A wrong "unwritable" warning appeared on nginx
 
- 
+## Scale of the release
 
- 
-
-There have been a lot of commits in our SVN repository since the latest release, so we can't cover all changes in this blog post. Please [download Dotkernel 1.8.0 (LTS)](http://www.dotkernel.com/download/?did=41) try it out yourself and tell us what you think.
-
- 
+There were a lot of commits in the SVN repository since the previous release, so the blog post only covers the highlights.
 
 ## FAQ
 
@@ -90,3 +81,11 @@ A: WURFL integration was removed (mobile device detection is now handled separat
 
 **Q: What security-related additions does 1.8.0 include?**
 A: A security scan in the Admin Dashboard shows recommended settings, admin failed-login notifications are sent to all developers listed in devEmails (not just the first admin), and a new Alert System can notify developers if something goes wrong.
+
+## Resources
+
+- What is LTS: http://www.dotkernel.com/long-term-support
+- Caching in Dotkernel using Zend Framework: http://www.dotkernel.com/dotkernel/caching-in-dotkernel-using-zend-framework/
+- Dotkernel reserved variable names for caching: http://www.dotkernel.com/dotkernel/dotkernel-reserved-variable-names-for-caching/
+- How to use alerts in Dotkernel: http://www.dotkernel.com/dotkernel/how-to-use-alerts-in-dotkernel/
+- Dotkernel 1.8.0 (LTS) download: http://www.dotkernel.com/download/?did=41
diff --git a/public/md-articles/dotkernel/dotkernel-1-8-1-upgrade-from-1-8-0-released.md b/public/md-articles/dotkernel/dotkernel-1-8-1-upgrade-from-1-8-0-released.md
index 962b96d6..2b3beb03 100644
--- a/public/md-articles/dotkernel/dotkernel-1-8-1-upgrade-from-1-8-0-released.md
+++ b/public/md-articles/dotkernel/dotkernel-1-8-1-upgrade-from-1-8-0-released.md
@@ -11,20 +11,19 @@ language: "en"
 # Dotkernel 1.8.1 + Upgrade from 1.8.0 Released
 
 ## TL;DR
+
 Dotkernel 1.8.1 was released with Enhanced Cache Support, allowing cache tags to be used if the hosting environment supports them.
 A dedicated upgrade package is available for users coming from 1.8.0.
 
-Dotkernel 1.8.1 was just released.
-
-Changes to Dotkernel in the latest release: - Enhanced Cache Support, which means you can use tags in your cache system if the host suports it
-
-Here are some useful download links:
+## What's new
 
-[Dotkernel 1.8.1](http://www.dotkernel.com/download/?did=42)
+- Enhanced Cache Support - you can use tags in your cache system if the host supports it
 
-[Upgrade from Dotkernel 1.8.0](http://www.dotkernel.com/download/?did=43)
+## Download links
 
-[Dotkernel 1.8.0 (LTS)](http://www.dotkernel.com/download/?did=41)
+- Dotkernel 1.8.1 (full package)
+- Upgrade from Dotkernel 1.8.0
+- Dotkernel 1.8.0 (LTS)
 
 ## FAQ
 
@@ -33,3 +32,9 @@ A: The main change is Enhanced Cache Support, which means you can use tags in yo
 
 **Q: How do I upgrade from 1.8.0 to 1.8.1?**
 A: The post provides a dedicated "Upgrade from Dotkernel 1.8.0" download link, separate from the full Dotkernel 1.8.1 package and the original Dotkernel 1.8.0 (LTS) download.
+
+## Resources
+
+- Dotkernel 1.8.1: http://www.dotkernel.com/download/?did=42
+- Upgrade from Dotkernel 1.8.0: http://www.dotkernel.com/download/?did=43
+- Dotkernel 1.8.0 (LTS): http://www.dotkernel.com/download/?did=41
diff --git a/public/md-articles/dotkernel/dotkernel-coding-standard.md b/public/md-articles/dotkernel/dotkernel-coding-standard.md
index d4ce2ef3..648b295e 100644
--- a/public/md-articles/dotkernel/dotkernel-coding-standard.md
+++ b/public/md-articles/dotkernel/dotkernel-coding-standard.md
@@ -11,34 +11,37 @@ language: "en"
 # Dotkernel Coding Standard
 
 ## TL;DR
+
 Dotkernel is a "skeleton" of Zend Framework and borrows its coding standard from the ZF Coding Standard, with a small number of exceptions covering indentation, naming conventions, and brace placement.
 
-**Dotkernel** will be a "skeleton"of [**Zend Framework**](http://framework.zend.com/). Dotkernel borrowed the coding standard from Zend Framework: **[ZF Coding Standard](http://framework.zend.com/manual/en/coding-standard.php-file-formatting.html)** with some exceptions.
+## Indentation
 
-In what follows, we will make remarks only on those features that are slightly different in the coding standards of Dotkernel.
+Indentation is made with tabs, not spaces (per section B.2.2 of the Zend Framework Coding Standard).
 
-[**B.2. PHP File Formatting**](http://framework.zend.com/manual/en/coding-standard.php-file-formatting.html)
+## Naming conventions
 
-- [**B.2.2. Indentation**](http://framework.zend.com/manual/en/coding-standard.php-file-formatting.html#coding-standard.php-file-formatting.indentation)
+Dotkernel uses camel naming conventions, with these Dotkernel-specific rules:
 
-[**B.3. Naming Conventions**](http://framework.zend.com/manual/en/coding-standard.naming-conventions.html)
+| Element | Convention | Example |
+|---|---|---|
+| Classes | Start with `Dot_` | `Dot_Templates` |
+| Interfaces | End with the string "Interface" | `Dot_Db_Interface` |
+| Filenames | Always use the `.php` extension, no fancy extensions | `.php`, not `.inc` |
 
-Camel naming convention
+## Control statements - brace placement
 
-- [**B.3.1. Classes**](http://framework.zend.com/manual/en/coding-standard.naming-conventions.html#coding-standard.naming-conventions.classes)
-- **[B.3.2. Interfaces](http://framework.zend.com/manual/en/coding-standard.naming-conventions.html#coding-standard.naming-conventions.interfaces)**
-- **[B.3.3. Filenames](http://framework.zend.com/manual/en/coding-standard.naming-conventions.html#coding-standard.naming-conventions.filenames)**
+Every opening curly brace `{` starts on its own new line after the statement, and its matching closing brace `}` is also placed on its own new line, aligned in the same column as the opening brace, for better indentation of the code.
 
-[**B.4.6. Control Statements**](http://framework.zend.com/manual/en/coding-standard.coding-style.html#coding-standard.coding-style.control-statements) every starting curly brace **}** after a statement starts on a new line, end it's closing curly brace **}** will be on a new line too. The start and end braces must be on the same column (for better indentation of the code) e.g:
+Example:
 
-```
+```php
 if ($a != 2)
 {
    $a = 2;
 }
 ```
 
-```
+```php
 if ($a != 2)
 {
     $a = 2;
@@ -62,3 +65,14 @@ A: Classes start with the prefix Dot_ (e.g. Dot_Templates), interfaces end with
 
 **Q: How should curly braces be placed for control statements?**
 A: Every opening curly brace starts on its own new line after the statement, and its matching closing brace also goes on a new line, aligned in the same column as the opening brace, for better indentation of the code.
+
+## Resources
+
+- Zend Framework: http://framework.zend.com/
+- ZF Coding Standard: http://framework.zend.com/manual/en/coding-standard.php-file-formatting.html
+- ZF Coding Standard - Indentation: http://framework.zend.com/manual/en/coding-standard.php-file-formatting.html#coding-standard.php-file-formatting.indentation
+- ZF Coding Standard - Naming Conventions: http://framework.zend.com/manual/en/coding-standard.naming-conventions.html
+- ZF Coding Standard - Classes: http://framework.zend.com/manual/en/coding-standard.naming-conventions.html#coding-standard.naming-conventions.classes
+- ZF Coding Standard - Interfaces: http://framework.zend.com/manual/en/coding-standard.naming-conventions.html#coding-standard.naming-conventions.interfaces
+- ZF Coding Standard - Filenames: http://framework.zend.com/manual/en/coding-standard.naming-conventions.html#coding-standard.naming-conventions.filenames
+- ZF Coding Standard - Control Statements: http://framework.zend.com/manual/en/coding-standard.coding-style.html#coding-standard.coding-style.control-statements
diff --git a/public/md-articles/dotkernel/dotkernel-database-naming-conventions-for-mysql.md b/public/md-articles/dotkernel/dotkernel-database-naming-conventions-for-mysql.md
index 91f664c2..6fc2141f 100644
--- a/public/md-articles/dotkernel/dotkernel-database-naming-conventions-for-mysql.md
+++ b/public/md-articles/dotkernel/dotkernel-database-naming-conventions-for-mysql.md
@@ -11,22 +11,24 @@ language: "en"
 # Dotkernel Database Naming Conventions for MySQL
 
 ## TL;DR
+
 Dotkernel's database naming conventions are borrowed from FaZend's "Rules of naming of database tables and columns."
 Tables use singular, camelLetter names, every table has an auto-increment id, foreign keys are named after the referenced table and column, and SQL keywords are capitalized.
 
-Dotkernel borrows the database naming conventions from [FaZend: Rules of naming of database tables and columns](http://fazend.com/a/2009-11-DataNaming.html). FaZend is an open-source PHP framework based on Zend Framework. **Database naming conventions for tables and columns:**
+## Database naming conventions for tables and columns
 
-- Singular table names only (e.g. *user*, *category*, *product*, *order, orderProduct*)
-- Every table must have an auto-incrementing integer column id
-- ZF-like names of columns and tables (e.g. *user::isAdmin*, *orderProduct::product*)
-- ~~Foreign keys must have the same names as reference tables~~
-- Foreign keys must have the same names as reference tables + the name of the referenced column **Example:** table referenced: *admin* , column name: *Id* so the column will be *adminId*
-- Pattern for CONSTRAINT name : FK_referencedTableName_tableName **Example:** CONSTRAINT `FK_admin_adminLogin`
-- SQL keywords are capitalized (e.g. SELECT, INT)
+- Singular table names only (e.g. `user`, `category`, `product`, `order`, `orderProduct`)
+- Every table must have an auto-incrementing integer column `id`
+- ZF-like names of columns and tables (e.g. `user::isAdmin`, `orderProduct::product`)
+- Foreign keys must have the same name as the referenced table plus the name of the referenced column.
+  Example: table referenced is `admin`, column name `Id`, so the foreign key column will be `adminId`.
+- Pattern for CONSTRAINT name: `FK_referencedTableName_tableName`.
+  Example: `CONSTRAINT FK_admin_adminLogin`.
+- SQL keywords are capitalized (e.g. `SELECT`, `INT`)
 
-**Example of proper SQL file formatting and naming:**
+## Example of proper SQL file formatting and naming
 
-```
+```sql
 CREATE TABLE IF NOT EXISTS `user`
  (
    `id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
@@ -35,7 +37,7 @@ CREATE TABLE IF NOT EXISTS `user`
    `email` VARCHAR(100) NOT NULL,
    `firstName` VARCHAR(255) NOT NULL,
    `lastName` VARCHAR(255) NOT NULL,
-   `dateCreated` TIMESTAMP NOT  NULL DEFAULT  CURRENT_TIMESTAMP,
+   `dateCreated` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `userType` INT(11) NOT NULL AUTO_INCREMENT
    `isActive` ENUM('0','1') NOT NULL DEFAULT '1',
    PRIMARY KEY  (`id`),
@@ -50,7 +52,9 @@ CREATE TABLE IF NOT EXISTS `user`
  AUTO_INCREMENT=1 ;
 ```
 
-**Conclusion:** The names of database tables and columns must follow *camelLetter* as naming conventions.s
+## Conclusion
+
+The names of database tables and columns must follow camelLetter naming conventions.
 
 ## FAQ
 
@@ -61,10 +65,15 @@ A: They are borrowed from FaZend's "Rules of naming of database tables and colum
 A: Singular table names only, for example user, category, product, order, orderProduct.
 
 **Q: How should foreign key columns be named?**
-A: A foreign key column takes the name of the referenced table plus the name of the referenced column. For example, referencing table admin's Id column produces a column named adminId.
+A: A foreign key column takes the name of the referenced table plus the name of the referenced column.
+For example, referencing table admin's Id column produces a column named adminId.
 
 **Q: What naming pattern is used for CONSTRAINT names?**
 A: The pattern is FK_referencedTableName_tableName, for example CONSTRAINT `FK_admin_adminLogin`.
 
 **Q: What casing convention applies to table/column names and to SQL keywords?**
 A: Table and column names must follow camelLetter naming conventions, while SQL keywords such as SELECT and INT are capitalized.
+
+## Resources
+
+- FaZend: Rules of naming of database tables and columns: http://fazend.com/a/2009-11-DataNaming.html
diff --git a/public/md-articles/dotkernel/dotkernel-light-starting-with-mezzio-microframework-and-laminas-components.md b/public/md-articles/dotkernel/dotkernel-light-starting-with-mezzio-microframework-and-laminas-components.md
index 649c3cf4..076cea00 100644
--- a/public/md-articles/dotkernel/dotkernel-light-starting-with-mezzio-microframework-and-laminas-components.md
+++ b/public/md-articles/dotkernel/dotkernel-light-starting-with-mezzio-microframework-and-laminas-components.md
@@ -11,49 +11,47 @@ language: "en"
 # Dotkernel Light - Starting with Mezzio microframework and Laminas components
 
 ## TL;DR
+
 Dotkernel Light is a version of Dotkernel Frontend that includes only the bare-bones essentials.
 It's built on the Mezzio microframework using Laminas components, and is designed as a presentation site, a fast-start introduction to Mezzio, or a clean starting point for a project where you want full control over functionality.
 
-**Dotkernel Light** is the smallest complete Mezzio application that includes only the bare-bones essentials. Though simpler than Frontend, it's perfect for:
-
-- A presentation site,
-- An introduction into the Mezzio microframework architecture,
-- A starting point for a more complex project where you have full control over functionality.
-
 ## Goal
 
-**Dotkernel Light** is the smallest complete Mezzio application, designed at the same time to be a fast-start example of using **Mezzio microframework**, as well as of using an **entry-level version** of Dotkernel Frontend. Primarily, its purpose is to present the **novice developer** with as few moving parts as possible. It's also a perfect starting point for the more **advanced developer** who wants full control of the platform's functionality.
+Dotkernel Light is designed to be a fast-start example of using the Mezzio microframework, as well as an entry-level version of Dotkernel Frontend.
+Its purpose is to present the newbie developer with as few moving parts as possible, while also giving the more advanced developer a starting point with full control of the platform's functionality.
 
-Light retains the modern architecture of **Mezzio microframework** and several **Laminas components** used in Dotkernel Frontend. The low number of out-of-box components **encourages the active exploration of functionality** required by your application. Basically, you add only the packages your application needs.
+Light retains the modern architecture of Mezzio microframework and several Laminas components used in Dotkernel Frontend.
+The low number of out-of-the-box components encourages active exploration of the functionality required by your application - you add only the packages your application needs.
 
 ## Components and functionality
 
-We designed Dotkernel Light to be the smallest complete Mezzio application, a stripped-down version of Dotkernel Frontend. Just like Dotkernel Frontend, Dotkernel Light is built on top of the Mezzio microframework using Laminas components. The big difference is the limited features and thus the lower number of packages. This makes the **learning curve** of working with the repo considerably gentler.
+Dotkernel Light is a stripped-down version of Dotkernel Frontend.
+Like Frontend, it is built on top of Mezzio microframework using Laminas components, but with limited features and a lower number of packages, which makes the learning curve of working with the repo considerably gentler.
 
-Currently, Light contains this **functionality**:
+### Functionality retained
 
 - Routing
 - Templating
 - Error handling
 - Tests and code quality checks
 
-Compared to Frontend, Light had these **items removed**:
+### Items removed compared to Frontend
 
-- Doctrine and all database related stuff
+- Doctrine and all database-related stuff
 - Sessions/Cookies/Flash messages
 - Authentication/Authorization
 - Dependency Injection
-- Mail related stuff
+- Mail-related stuff
 - Navigation
 - CORS
 - Forms/Validators/InputFilters
 - User module
 - Contact module
 - Plugin module
-- CSS/JS code that was no longer in use due to the above module removals
+- CSS/JS code no longer in use due to the above module removals
 - Instructions from README.md that are no longer needed
 
-As expected, several packages used by Frontend are not required:
+### Packages no longer required
 
 - dotkernel/dot-authorization
 - dotkernel/dot-data-fixtures
@@ -73,21 +71,14 @@ As expected, several packages used by Frontend are not required:
 - mezzio/mezzio-tooling
 - rector/rector
 
-## Useful links
-
-- [Dotkernel Light GitHub repository](https://github.com/dotkernel/light)
-- [Working demo of Dotkernel Light](https://light.dotkernel.net/)
-- [Dotkernel Light documentation](https://docs.dotkernel.org/light-documentation/)
-- [Laminas Project](https://getlaminas.org/)
-- [Documentation of Mezzio](https://docs.mezzio.dev/)
-
 ## FAQ
 
 **Q: What is Dotkernel Light?**
-A: Dotkernel Light is the smallest complete Mezzio application, a PSR-15 pipeline, routing and templating, with nothing to strip out. It's a good base for a presentation site, an introduction to the Mezzio microframework architecture, or a starting point for a more complex project where you want full control over functionality.
+A: Dotkernel Light is a version of Dotkernel Frontend that includes only the bare-bones essentials.
+It's suitable as a presentation site, an introduction to the Mezzio microframework architecture, or a starting point for a more complex project where you want full control over functionality.
 
 **Q: What is the goal of Dotkernel Light?**
-A: It's designed to be the smallest complete Mezzio application. It's a fast-start example of using the Mezzio microframework as well as an entry-level version of Dotkernel Frontend. It presents the novice developer with as few moving parts as possible, while still allowing the more advanced developer to have full control of the platform's functionality.
+A: It's designed to be a fast-start example of using the Mezzio microframework as well as an entry-level version of Dotkernel Frontend, presenting the beginner developer with as few moving parts as possible while still letting the more advanced developer have full control of the platform's functionality.
 
 **Q: What functionality does Dotkernel Light retain?**
 A: It keeps routing, templating, error handling, and tests and code quality checks.
@@ -97,3 +88,11 @@ A: Items removed include Doctrine and all database related stuff, sessions/cooki
 
 **Q: Which packages are no longer required in Dotkernel Light?**
 A: Packages such as dotkernel/dot-authorization, dotkernel/dot-mail, dotkernel/dot-session, dotkernel/dot-navigation, dotkernel/dot-flashmessenger, laminas/laminas-form, mezzio/mezzio-cors, and several others used by Frontend are not required.
+
+## Resources
+
+- Dotkernel Light GitHub repository: https://github.com/dotkernel/light
+- Working demo of Dotkernel Light: https://light.dotkernel.net/
+- Dotkernel Light documentation: https://docs.dotkernel.org/light-documentation/
+- Laminas Project: https://getlaminas.org/
+- Documentation of Mezzio: https://docs.mezzio.dev/
diff --git a/public/md-articles/dotkernel/dotkernel-light-the-best-choice-for-your-presentation-site.md b/public/md-articles/dotkernel/dotkernel-light-the-best-choice-for-your-presentation-site.md
index 1317b343..ebd417e2 100644
--- a/public/md-articles/dotkernel/dotkernel-light-the-best-choice-for-your-presentation-site.md
+++ b/public/md-articles/dotkernel/dotkernel-light-the-best-choice-for-your-presentation-site.md
@@ -11,54 +11,45 @@ language: "en"
 # Dotkernel Light: the best choice for your presentation site
 
 ## TL;DR
+
 Dotkernel Light is a lightweight starting point for a project when you want full control over its functionality, and it grows into something more complex as you add packages.
 It comes with routing, templating, error handling, and tests/code quality checks out of the box, but strips out everything a presentation site doesn't need - database, sessions/cookies/flash messages, auth, dependency injection, mail, navigation, CORS, forms, the user/contact/plugin modules.
 
-**Dotkernel Light** is the smallest complete Mezzio application and a good starting point for a project if you want to have **full control over the functionality** it contains. It **can be expanded** into something more complex with the integration of packages based on your requirements.
-
-Its out-of-box functionality is suitable for a **presentation site**:
-
-- Routing
-- Templating
-- Error handling
-- Tests and code quality checks
-
-Presentation sites don't require features that are present in Dotkernel Frontend. The goal of Dotkernel Light is to have **no clutter**, so these features are removed:
-
-- Everything related to the database
-- Sessions/Cookies/Flash messages
-- Authentication/Authorization
-- Dependency Injection
-- Mail related stuff
-- Navigation
-- CORS
-- Forms/Validators/InputFilters
-- User module
-- Contact module
-- Plugin module
-
-## The goal of this article
-
-In this article we explore how to use Dotkernel Light for a simple presentation site. We will mention what files to focus on to teach you how to add more pages of content to your site and how to manage their assets.
-
-### Adding new pages
-
-The first step is to add the new pages in `src/Page/src/Controller/PageController.php`. This means adding an `Action` function for each page, as seen below.
-
-```
-    public function examplePageAction(): ResponseInterface
-    {
-        return new HtmlResponse(
-            $this->template->render('page::example-template')
-        );
-    }
+## What's included vs. removed
+
+| Included out of the box | Removed (not needed for a presentation site) |
+|---|---|
+| Routing | Everything related to the database |
+| Templating | Sessions/Cookies/Flash messages |
+| Error handling | Authentication/Authorization |
+| Tests and code quality checks | Dependency Injection |
+| | Mail related stuff |
+| | Navigation |
+| | CORS |
+| | Forms/Validators/InputFilters |
+| | User module |
+| | Contact module |
+| | Plugin module |
+
+## Adding new pages
+
+1. Add an `Action` function for the page in `src/Page/src/Controller/PageController.php`, for example:
+
+```php
+public function examplePageAction(): ResponseInterface
+{
+    return new HtmlResponse(
+        $this->template->render('page::example-template')
+    );
+}
 ```
 
-> The url for the new page in this example is `/page/example-page`.
+   The URL for this example page would be `/page/example-page`.
 
-Each page has its own template, so the next step is to create the template files in the `src/Page/templates/page/` folder. For the example above, the `src/Page/templates/page/example-template.html.twig` file was created. We won't include the entire code here, just the basic building blocks. The `content` block is where your page copy goes.
+2. Create the matching template in `src/Page/templates/page/` - for the example above, `src/Page/templates/page/example-template.html.twig`.
+Put the page copy inside the `content` block:
 
-```
+```twig
 {% extends '@layout/default.html.twig' %}
 
 {% block title %}Page Title{% endblock %}
@@ -78,33 +69,26 @@ Each page has its own template, so the next step is to create the template files
 {% endblock %}
 ```
 
-> Make sure to check the header for any fonts your content requires.
-
-If you haven't already done so, make sure the `npm` is installed and running during your updates with `npm run watch` or run this command after the edits are completed `npm run prod`.
+   Make sure to check the header for any fonts your content requires.
 
-The assets should be copied under the `src/App/assets/` folder.
-These are the default asset folders:
+3. Place assets under `src/App/assets/`, in the default folders:
+   - `src/App/assets/fonts`
+   - `src/App/assets/images`
+   - `src/App/assets/js`
+   - `src/App/assets/scss`
 
-- src/App/assets/fonts
-- src/App/assets/images
-- src/App/assets/js
-- src/App/assets/scss
+   Make sure `npm` is installed and running during updates with `npm run watch`, or run `npm run prod` after edits are completed.
 
 ## Optional items
 
 ### Twitter and OpenGraph cards
 
-If you want to promote the pages on other platforms, a helpful item is the header section in the `src/App/templates/layout/default.html.twig` file. This is where the Twitter (X) and OpenGraph cards should be placed.
+To promote pages on other platforms, edit the header section in `src/App/templates/layout/default.html.twig`, where the Twitter (X) and OpenGraph cards are placed. Update all items based on your page content.
 
-Make sure to update all items based on your page content.
+- `{{ url('home') }}` generates the homepage URL, and the same pattern is used for other pages, as in the canonical URL block: `{% block canonical %}{{ url(routeName ?? null) }}{% endblock %}` (the `block` is present to handle not-found pages, e.g. mistyped URLs).
+- An image referenced as `{{ url('home') }}images/app/My-image.png` is found at `public/images/app/My-image.png`, copied there by the `npm` script from `src/App/assets/images/PHP-REST-API.png`.
 
-> In the example:
-> 
-> - `{{ url('home') }}` is the URL for the homepage, but you can also use this code to generate the url for other pages, just like in the canonical URL `{% block canonical %}{{ url(routeName ?? null) }}{% endblock %}`
->   - The `block` item is present to mitigate for not-found pages, e.g. when the url is typed incorrectly
-> - The image from `{{ url('home') }}images/app/My-image.png` is found in `public/images/app/My-image``.png`, but it is copied there by the `npm` script from `src/App/assets/images/PHP-REST-API.png`.
-
-```
+```html
 <!-- Twitter card -->
 <meta name="twitter:card" content="summary_large_image">
 <meta name="twitter:site" content="@example">
@@ -123,9 +107,10 @@ Make sure to update all items based on your page content.
 
 ### Top menu
 
-This menu is displayed on all of the pages, in the header. To edit it, go to `src/App/templates/layout/default.html.twig` and update the items under `id="navbarHeader"`. You can use the below as an example.
+This menu is displayed on all pages, in the header.
+Edit it in `src/App/templates/layout/default.html.twig`, under `id="navbarHeader"`:
 
-```
+```html
 <div class="menu" id="navbarHeader">
     <ul class="navbar-nav mr-auto">
     <li class="nav-item">
@@ -138,23 +123,12 @@ This menu is displayed on all of the pages, in the header. To edit it, go to `sr
 </div>
 ```
 
-> You can also replace the `nav-item` class for the `li` elements with `button-border` for a link that looks more like a button.
+You can replace the `nav-item` class for the `li` elements with `button-border` for a link that looks more like a button.
 
 ### Footer
 
-To edit the footer on all of the pages, search for `<footer class="app-footer">` in the `src/App/templates/layout/default.html.twig` template. We won't include an example here, since the content is usually basic `HTML` and `CSS` with `twig` elements already covered in this article.
-
-## The result of your hard work
-
-Whew, well done! That's all there is to it.
-
-Now you should have a basic idea on how to work on a presentation site. You know how to expand the site with more pages, where to place the assets and how to promote the site.
-
-## Useful links
-
-- See a working example [dotkernel.org](https://www.dotkernel.org)
-- [Dotkernel Light](https://github.com/dotkernel/light)
-- More from [Dotkernel](https://github.com/dotkernel)
+To edit the footer on all pages, search for `<footer class="app-footer">` in `src/App/templates/layout/default.html.twig`.
+Its content is usually basic HTML and CSS with twig elements already covered above.
 
 ## FAQ
 
@@ -171,7 +145,14 @@ A: Everything related to the database, Sessions/Cookies/Flash messages, Authenti
 A: Add an Action function for the page (e.g. examplePageAction()) in src/Page/src/Controller/PageController.php that renders a template, then create the matching template file in src/Page/templates/page/ (e.g. example-template.html.twig), with the page copy placed in its content block.
 
 **Q: Where should new page assets like fonts, images, JS, and CSS be placed?**
-A: Under src/App/assets/, in its default folders: src/App/assets/fonts, src/App/assets/images, src/App/assets/js, and src/App/assets/scss. Run npm run watch during edits, or npm run prod once the edits are completed.
+A: Under src/App/assets/, in its default folders: src/App/assets/fonts, src/App/assets/images, src/App/assets/js, and src/App/assets/scss.
+Run npm run watch during edits, or npm run prod once the edits are completed.
 
 **Q: Where do you edit the top menu and footer that appear on every page?**
 A: Both live in src/App/templates/layout/default.html.twig: the top menu items are under id="navbarHeader", and the footer content is inside the footer element with class "app-footer".
+
+## Resources
+
+- [dotkernel.org](https://www.dotkernel.org) - a working example
+- [Dotkernel Light](https://github.com/dotkernel/light)
+- [More from Dotkernel](https://github.com/dotkernel)
diff --git a/public/md-articles/dotkernel/dotkernel-on-nginx.md b/public/md-articles/dotkernel/dotkernel-on-nginx.md
index 195f9ff9..71f47aea 100644
--- a/public/md-articles/dotkernel/dotkernel-on-nginx.md
+++ b/public/md-articles/dotkernel/dotkernel-on-nginx.md
@@ -11,24 +11,55 @@ language: "en"
 # Dotkernel on Nginx
 
 ## TL;DR
+
 Since Nginx was becoming the buzzword instead of Apache, this article tests Dotkernel on Nginx and documents the configuration needed: server block settings, a `try_files` directive in place of `.htaccess`, PHP-FPM handling, and protecting the `configs` folder.
 
-Due to the fact that the current buzzword is **Nginx** instead of **Apache**, we decided to test if Dotkernel is running out of the box on it. And how to configure Nginx :-)
-
-1. Installed on a clean Centos 6.3 VPS : Nginx 1.4.1 , PHP 5.4.16 , PHP-FPM
-2. Installed PHP modules: APC, GeoIP and such.
-3. Installed PEAR and Zend Framework from [http://code.google.com/p/zend/](http://code.google.com/p/zend/)
-4. Fine tune php.ini file: date, default charset, include path, etc
-5. Create on a remote server a MySql database, allow permissions from Nginx server  IP to connect to it.
-6. Now the fine part: editing the **Nginx** config ( in our case */etc/nginx/conf.d/default.conf*)
-  - Set server name: server_name nginx.dotkernel.net;
-  - Set document root , in the location / area root /var/www/html;
-  - Equivalent of the main .htaccess file is try_files $uri $uri/ /index.php; This directive will send all requests to index.php file
-  - Set the location for php directive location ~ \.php$ { root /var/www/html; fastcgi_pass 127.0.0.1:9000; fastcgi_index index.php; fastcgi_param SCRIPT_FILENAME /var/www/html$fastcgi_script_name; fastcgi_param APPLICATION_ENV staging; include fastcgi_params; } In the lines above , you can change the value for APPLICATION_ENV into *production* or *development*
-  - Protect *configs* folder from web access #protect folders location ~ ^/configs/ { deny all; }
-7.   Export a Dotkernel copy from SVN svn export --force http://v1.dotkernel.net/svn/trunk/ /var/www/html
-8. Edit ***application.ini*** to reflect the current settings and check if is  protected [http://nginx.dotkernel.net/configs/application.ini](http://nginx.dotkernel.net/configs/application.ini)
-9. And walla, site is running on Nginx       [http://nginx.dotkernel.net/](http://nginx.dotkernel.net/) *Admin login is disabled due to security reason.*
+## Setup steps
+
+1. Installed on a clean CentOS 6.3 VPS: Nginx 1.4.1, PHP 5.4.16, PHP-FPM.
+2. Installed PHP modules: APC, GeoIP, and others.
+3. Installed PEAR and Zend Framework from the PEAR ZF channel (`http://code.google.com/p/zend/`).
+4. Fine-tuned `php.ini`: date, default charset, include path, etc.
+5. Created a MySQL database on a remote server and allowed permissions from the Nginx server's IP to connect to it.
+6. Edited the Nginx config (`/etc/nginx/conf.d/default.conf`):
+   - Set the server name:
+     ```
+     server_name  nginx.dotkernel.net;
+     ```
+   - Set the document root, in the `location /` area:
+     ```
+     root   /var/www/html;
+     ```
+   - The equivalent of the main `.htaccess` file, sending all requests to `index.php`:
+     ```
+     try_files    $uri $uri/ /index.php;
+     ```
+   - Set the location for the PHP directive:
+     ```
+     location ~ \.php$ {
+                root           /var/www/html;
+                fastcgi_pass   127.0.0.1:9000;
+                fastcgi_index  index.php;
+                fastcgi_param  SCRIPT_FILENAME  /var/www/html$fastcgi_script_name;
+                fastcgi_param APPLICATION_ENV staging;
+                include        fastcgi_params;
+     }
+     ```
+     `APPLICATION_ENV` can be changed to `production` or `development`.
+   - Protect the `configs` folder from web access:
+     ```
+     #protect folders
+     location ~ ^/configs/ {
+             deny all;
+     }
+     ```
+7. Exported a Dotkernel copy from SVN:
+   ```shell
+   svn export --force  http://v1.dotkernel.net/svn/trunk/ /var/www/html
+   ```
+8. Edited `application.ini` to reflect the current settings, and checked that it was protected.
+9. Result: the site was running on Nginx.
+Admin login was disabled on the demo for security reasons.
 
 ## FAQ
 
@@ -36,10 +67,16 @@ Due to the fact that the current buzzword is **Nginx** instead of **Apache**, we
 A: A clean CentOS 6.3 VPS running Nginx 1.4.1, PHP 5.4.16, and PHP-FPM, with the APC and GeoIP PHP modules installed.
 
 **Q: What is the Nginx equivalent of the main .htaccess file?**
-A: The directive try_files $uri $uri/ /index.php;, which sends all requests to the index.php file.
+A: The directive `try_files $uri $uri/ /index.php;`, which sends all requests to the index.php file.
 
 **Q: How is the configs folder protected from web access in Nginx?**
-A: By adding a location block matching ^/configs/ that returns deny all;.
+A: By adding a location block matching `^/configs/` that returns `deny all;`.
 
 **Q: How was the Dotkernel codebase deployed onto the server?**
-A: It was exported directly from SVN using svn export --force http://v1.dotkernel.net/svn/trunk/ /var/www/html.
+A: It was exported directly from SVN using `svn export --force http://v1.dotkernel.net/svn/trunk/ /var/www/html`.
+
+## Resources
+
+- [PEAR ZF Channel](http://code.google.com/p/zend/)
+- [application.ini example](http://nginx.dotkernel.net/configs/application.ini)
+- [Live Nginx demo](http://nginx.dotkernel.net/)
diff --git a/public/md-articles/dotkernel/dotkernel-reserved-variable-names-for-caching.md b/public/md-articles/dotkernel/dotkernel-reserved-variable-names-for-caching.md
index f075b192..66f8270c 100644
--- a/public/md-articles/dotkernel/dotkernel-reserved-variable-names-for-caching.md
+++ b/public/md-articles/dotkernel/dotkernel-reserved-variable-names-for-caching.md
@@ -11,61 +11,43 @@ language: "en"
 # Dotkernel Reserved Variable Names for Caching
 
 ## TL;DR
-This article is a follow-up to "Caching in Dotkernel Using Zend Framework Cache" and lists the variables Dotkernel caches, along with the exact cache key each one uses.
-
-This article is related to: [Caching in Dotkernel with Zend Framework Cache](http://www.dotkernel.com/dotkernel/caching-in-dotkernel-using-zend-framework)
-
-The variables that Dotkernel cache are below:
-
-## Router
-
-Router is the object that load routes (modules, controllers, actions) settings from router.xml file. More info about router: [http://www.dotkernel.com/docs/router-xml/](http://www.dotkernel.com/docs/router-xml/)
-
-The router is cached as ***router.***
-
-## Auth / ACL Role
-
-The object which authorizes user methods (aka Dot_Auth), used in all Dotkernel Applications, Dot_Auth uses */configs/acl/role.xml* to define the users rights.
-
-The *role.xml* file is cached as ***acl_role**.*
 
-## Menu
-
-The menu.xml from current ***module**([what is a module?](http://www.dotkernel.com/docs/module-structure/))* More about menu.xml : *[http://www.dotkernel.com/docs/menu-xml/](http://www.dotkernel.com/docs/menu-xml/)*
-
-The menu is cached as ***admin_menu***, ***frontend_menu*****.**
-
-## Options
-
-The options are the ones found in /configs/dots/ and have the following naming format: **option_MODULE_CONTROLLER**.
-
-MODULE is the current module and CONTROLLER is the current controller or "seo", so the options cache entries will look like:
-
-- option_admin_Admin
-- option_frontend_Page
-- option_admin_seo (yes, seo is lowercase)
+This article is a follow-up to "Caching in Dotkernel Using Zend Framework Cache" and lists the variables Dotkernel caches, along with the exact cache key each one uses.
 
-## Browser & OS
+## Cached variables
 
-The browser.xml and os.xml are used to identify the Browser and OS name, icon, and type. Theese XML files are located in /configs/useragent/.
+| Item | Source | Cache key(s) |
+|---|---|---|
+| Router | Loads routes (modules, controllers, actions) settings from `router.xml` | `router` |
+| Auth / ACL Role | `Dot_Auth`'s `/configs/acl/role.xml`, defining user rights | `acl_role` |
+| Menu | `menu.xml` from the current module | `admin_menu`, `frontend_menu` |
+| Options | Files found in `/configs/dots/` | `option_MODULE_CONTROLLER`, e.g. `option_admin_Admin`, `option_frontend_Page`, `option_admin_seo` (seo is lowercase) |
+| Browser & OS | `browser.xml` and `os.xml` in `/configs/useragent/`, identifying browser/OS name, icon, and type | `browser_xml`, `os_xml` |
 
-Browser & OS are cached as ***browser_xml** and **os_xml.***
+## Important note
 
-**Note: Be careful when changing the xml files / values to be cached as they remain cached. If there is no effect that means you must clear the cache or rewrite that value in cache.**
+Be careful when changing the XML files or values that get cached, as they remain cached. If a change appears to have no effect, you must clear the cache or rewrite that value in the cache.
 
 ## FAQ
 
 **Q: What cache key is used for the router?**
-A: The router, which loads routes settings from router.xml, is cached as router.
+A: The router, which loads routes settings from router.xml, is cached as `router`.
 
 **Q: What cache key stores the ACL role definitions?**
-A: The role.xml file (used by Dot_Auth, from /configs/acl/role.xml, to define user rights) is cached as acl_role.
+A: The role.xml file (used by Dot_Auth, from /configs/acl/role.xml, to define user rights) is cached as `acl_role`.
 
 **Q: How is the menu cached?**
-A: The menu.xml from the current module is cached as admin_menu and frontend_menu.
+A: The menu.xml from the current module is cached as `admin_menu` and `frontend_menu`.
 
 **Q: What naming pattern do cached options use?**
-A: option_MODULE_CONTROLLER, where MODULE is the current module and CONTROLLER is the current controller or "seo" — for example option_admin_Admin, option_frontend_Page, and option_admin_seo (seo is lowercase).
+A: `option_MODULE_CONTROLLER`, where MODULE is the current module and CONTROLLER is the current controller or "seo" - for example `option_admin_Admin`, `option_frontend_Page`, and `option_admin_seo` (seo is lowercase).
 
 **Q: What happens if you change browser.xml, os.xml, or other cached config files?**
-A: The change won't take effect on its own, since values like browser_xml and os_xml remain cached — you must clear the cache or rewrite that value in cache to see the change take effect.
+A: The change won't take effect on its own, since values like browser_xml and os_xml remain cached - you must clear the cache or rewrite that value in cache to see the change take effect.
+
+## Resources
+
+- [Caching in Dotkernel Using Zend Framework Cache](http://www.dotkernel.com/dotkernel/caching-in-dotkernel-using-zend-framework)
+- [router.xml documentation](http://www.dotkernel.com/docs/router-xml/)
+- [Module Structure](http://www.dotkernel.com/docs/module-structure/)
+- [menu.xml documentation](http://www.dotkernel.com/docs/menu-xml/)
diff --git a/public/md-articles/dotkernel/dotkernel-template-engine.md b/public/md-articles/dotkernel/dotkernel-template-engine.md
index 08479d15..22129c11 100644
--- a/public/md-articles/dotkernel/dotkernel-template-engine.md
+++ b/public/md-articles/dotkernel/dotkernel-template-engine.md
@@ -10,9 +10,9 @@ language: "en"
 
 # Dotkernel Template Engine
 
-## Dotkernel Template Engine is an implementation of PHPLib Template engine for PHP5.
-
-It has an amazing ability to separate the application code from the presentation layer. Separates the manipulation of data (in the database as well as in PHP) from its final format, whether that format is HTML, XML or a formatted e-mail. The big advantage is that is allowing us to change the look and feel of a site quickly without having to delve immediately into a lot of PHP variable assignments and print statements.
+Dotkernel Template Engine is an implementation of the PHPLib Template engine for PHP5.
+It has an amazing ability to separate the application code from the presentation layer, separating the manipulation of data (in the database as well as in PHP) from its final format, whether that format is HTML, XML, or a formatted e-mail.
+The big advantage is that it allows changing the look and feel of a site quickly without having to delve immediately into a lot of PHP variable assignments and print statements.
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel/dotkernel-version-1-0-in-action.md b/public/md-articles/dotkernel/dotkernel-version-1-0-in-action.md
index b726465d..12d595f5 100644
--- a/public/md-articles/dotkernel/dotkernel-version-1-0-in-action.md
+++ b/public/md-articles/dotkernel/dotkernel-version-1-0-in-action.md
@@ -11,35 +11,43 @@ language: "en"
 # Dotkernel version 1.0 in action
 
 ## TL;DR
+
 Dotkernel is DotBoost's in-house developed framework, built on top of Zend Framework and released under the Open Software License (OSL 3.0).
 It uses a simplified MVC architecture, easy to learn for beginner and intermediate programmers, by eliminating much of Zend Framework's complexity through a different approach to handling web requests.
 It relies on only a handful of Zend Framework classes.
 
-Dotkernel is the[DotBoost](http://www.dotboost.com)'s in-house developed framework, based on Zend Framework. **Dotkernel** is at version 1.0 , released under [Open Software License (OSL 3.0)](http://opensource.org/licenses/osl-3.0.php) , and is built on top of [Zend Framework](http://framework.zend.com/).
-
-Dotkernel is using a simplified **MVC (Model-View-Controller)** architecture, easy to learn by beginner and intermediate level programmers. It has eliminated the complexity of Zend Framework by using a different approach of how the web request are handled.
-
-## From Zend Framework, Dotkernel is using only the necessary classes:
+## Zend Framework classes Dotkernel relies on
 
-- **Zend_Config** - While Zend Framework itself is configuration-less, it's often necessary to have some way to specify configurable options. Zend_Config provides multiple backends for configuration storage, and a simple, intuitive, object-oriented interface for accessing it. We store configuration as simple PHP arrays, which are then wrapped by Zend_Config.
-- **Zend_Db and Zend_Db_Table** - Zend_Db_Table is a classic implementation of both the Table Data Gateway and Row Data Gateway design patterns, allowing for easy and  intuitive access to database tables and rows, as well as an entry point for custom business logic surrounding our data.
-- **Zend_Mail** - Zend_Mail provides generalized functionality to compose and send both text and MIME-compliant multipart e-mail messages. Mail can be sent with Zend_Mail via the default Zend_Mail_Transport_Sendmail transport or via Zend_Mail_Transport_Smtp.
-- **Zend_Registry** - A registry is a container for storing objects and values in the application space. By storing the value in a registry, the same object is always available throughout the application. This mechanism is an alternative to using global storage.
-- **Zend_Validate** - The Zend_Validate component provides a set of commonly needed validators. It also provides a simple validator chaining mechanism by which multiple validators may be applied to a single datum in a user-defined order.
+| Class | Purpose |
+|---|---|
+| `Zend_Config` | Provides multiple backends for configuration storage and a simple, intuitive, object-oriented interface for accessing it. Dotkernel stores configuration as simple PHP arrays, wrapped by Zend_Config. |
+| `Zend_Db` and `Zend_Db_Table` | A classic implementation of the Table Data Gateway and Row Data Gateway design patterns, for easy and intuitive access to database tables and rows, and an entry point for custom business logic. |
+| `Zend_Mail` | Generalized functionality to compose and send text and MIME-compliant multipart e-mail, via the default Zend_Mail_Transport_Sendmail transport or via Zend_Mail_Transport_Smtp. |
+| `Zend_Registry` | A container for storing objects and values in the application space, so the same object is always available throughout the application - an alternative to global storage. |
+| `Zend_Validate` | Provides a set of commonly needed validators, plus a simple validator chaining mechanism so multiple validators can be applied to a single datum in a user-defined order. |
 
 ## FAQ
 
 **Q: Who developed Dotkernel and what is it built on?**
-A: Dotkernel is DotBoost's in-house developed framework, built on top of Zend Framework. At the time of this article it was at version 1.0, released under the Open Software License (OSL 3.0).
+A: Dotkernel is DotBoost's in-house developed framework, built on top of Zend Framework.
+At the time of this article it was at version 1.0, released under the Open Software License (OSL 3.0).
 
 **Q: What architecture does Dotkernel use?**
 A: A simplified MVC (Model-View-Controller) architecture that's easy to learn for beginner and intermediate level programmers, achieved by eliminating much of Zend Framework's complexity through a different approach to handling web requests.
 
 **Q: What does Zend_Config provide in Dotkernel?**
-A: It provides multiple backends for configuration storage and a simple, intuitive, object-oriented interface for accessing it. Dotkernel stores configuration as simple PHP arrays, which are then wrapped by Zend_Config.
+A: It provides multiple backends for configuration storage and a simple, intuitive, object-oriented interface for accessing it.
+Dotkernel stores configuration as simple PHP arrays, which are then wrapped by Zend_Config.
 
 **Q: What role do Zend_Db and Zend_Db_Table play?**
 A: Zend_Db_Table is a classic implementation of the Table Data Gateway and Row Data Gateway design patterns, allowing easy and intuitive access to database tables and rows, as well as an entry point for custom business logic surrounding the data.
 
 **Q: What are Zend_Mail and Zend_Registry used for?**
-A: Zend_Mail composes and sends both text and MIME-compliant multipart e-mail, via the default Zend_Mail_Transport_Sendmail transport or via Zend_Mail_Transport_Smtp. Zend_Registry is a container for storing objects and values in the application space, so the same object is always available throughout the application, as an alternative to using global storage.
+A: Zend_Mail composes and sends both text and MIME-compliant multipart e-mail, via the default Zend_Mail_Transport_Sendmail transport or via Zend_Mail_Transport_Smtp.
+Zend_Registry is a container for storing objects and values in the application space, so the same object is always available throughout the application, as an alternative to using global storage.
+
+## Resources
+
+- [DotBoost](http://www.dotboost.com)
+- [Open Software License (OSL 3.0)](http://opensource.org/licenses/osl-3.0.php)
+- [Zend Framework](http://framework.zend.com/)
diff --git a/public/md-articles/dotkernel/forcing-utf8-connections-and-character-set-in-mysql.md b/public/md-articles/dotkernel/forcing-utf8-connections-and-character-set-in-mysql.md
index d0c57fc0..3bcc8596 100644
--- a/public/md-articles/dotkernel/forcing-utf8-connections-and-character-set-in-mysql.md
+++ b/public/md-articles/dotkernel/forcing-utf8-connections-and-character-set-in-mysql.md
@@ -11,27 +11,29 @@ language: "en"
 # Forcing UTF8 connections and character set in MySQL
 
 ## TL;DR
+
 In some situations it may be necessary to force the MySQL server's collation and character set to UTF8, since you can't control all the scripts connecting to your database (for instance the mysql command line or mysqldump).
 This is done by editing `my.cnf`.
 
-In some situations, it may be neccesar to force MySQL server collation and character set to UTF8. As you can't control all scripts that are connecting to your database( for instance: mysql command line, or mysqldump)
+## Steps
 
-For that , open the my.cnf file and add the below lines:
+1. Open the `my.cnf` file.
+2. Add the following lines to force UTF8 for all connections:
 
-```
+```shell
 character_set_server=utf8
 skip-character-set-client-handshake
 ```
 
-If you are interested in better performance, add the below line:
+3. If you're interested in better performance, also add:
 
-```
+```shell
 collation_server=utf8_general_ci
 ```
 
-If you are interested in better sorting order, add the below line instead:
+4. If you're interested in better sorting order instead, add this line rather than the one above:
 
-```
+```shell
 collation_server=utf8_unicode_ci
 ```
 
@@ -41,7 +43,7 @@ collation_server=utf8_unicode_ci
 A: Because you can't control all the scripts that connect to your database (for instance the mysql command line or mysqldump), so forcing the server's collation and character set to UTF8 in my.cnf guarantees it regardless of the connecting client.
 
 **Q: What two lines enable UTF8 for all connections in my.cnf?**
-A: character_set_server=utf8 and skip-character-set-client-handshake.
+A: `character_set_server=utf8` and `skip-character-set-client-handshake`.
 
 **Q: What's the difference between the two suggested collation settings?**
-A: collation_server=utf8_general_ci is recommended for better performance, while collation_server=utf8_unicode_ci is recommended instead if better sorting order matters more.
+A: `collation_server=utf8_general_ci` is recommended for better performance, while `collation_server=utf8_unicode_ci` is recommended instead if better sorting order matters more.
diff --git a/public/md-articles/dotkernel/geoip-city-removed-from-dotkernel.md b/public/md-articles/dotkernel/geoip-city-removed-from-dotkernel.md
index 277ad016..5ac2408f 100644
--- a/public/md-articles/dotkernel/geoip-city-removed-from-dotkernel.md
+++ b/public/md-articles/dotkernel/geoip-city-removed-from-dotkernel.md
@@ -11,61 +11,61 @@ language: "en"
 # GeoIP City Removed From Dotkernel
 
 ## TL;DR
+
 The newest Dotkernel version removed the GeoIP City integration because the City database on GeoIP extension version 1.1.0+ was causing a segmentation fault, crashing requests or outputting an error instead of executing the PHP code.
 Users on an older Dotkernel version combined with GeoIP >=1.1.0 may hit this.
 If you don't need GeoIP City, the affected code can be removed.
 
-In the newest version we have removed the GeoIP City integration. The City database on ***GeoIP 1.1.0*** extension was causing a segmentation fault, which resulted in crashing or outputting an error instead of executing the PHP Code.
-
-This error occurs due to the extension incompatibility with the database(dat) file. If you have an older Dotkernel version and version **>=1.1.0** of GeoIP you might get this error.
-
-On some operating systems Apache will respond your request with HTTP Status Code 200 (OK) and a web page containing the text below.
+## The error
 
-Error result:
+This error occurs because of an incompatibility between the GeoIP extension and the database (dat) file.
+On some operating systems, Apache still responds with HTTP Status Code 200 (OK), but with a page containing this text:
 
 ```
 The server encountered an internal error or
- misconfiguration and was unable to complete
- your request.
+misconfiguration and was unable to complete
+your request.
 ```
 
-The error might not be logged as the error is generated the GeoIP extension and not by your PHP code.
+The error might not be logged, since it's generated by the GeoIP extension itself rather than by your PHP code.
 
-If you don't want to use GeoIP City and just want to get rid of the error go to
+## How to remove GeoIP City if you don't need it
 
-- Dotkernel/admin/System.php (Admin/System model) and comment or remove the lines below
+1. In `Dotkernel/admin/System.php` (the `Admin/System` model), comment or remove the following lines:
 
-```
+```php
 if(geoip_db_avail(GEOIP_CITY_EDITION_REV0))
 {
-    $info = explode(" ",geoip_database_info(GEOIP_CITY_EDITION_REV0));
-    $return = $info.' '.Dot_Kernel::TimeFormat($info);
+    $info = explode(" ",geoip_database_info(GEOIP_CITY_EDITION_REV0));
+    $return = $info.' '.Dot_Kernel::TimeFormat($info);
 }
 ```
 
-- library/Dot/GeoIp.php (Dot_GeoIp class) and comment or remove the lines below
+2. In `library/Dot/GeoIp.php` (the `Dot_GeoIp` class), comment or remove the following lines:
 
-```
+```php
 if(function_exists('geoip_db_avail') && geoip_db_avail(GEOIP_CITY_EDITION_REV0)
 && 'unknown' == $country)
 {
-    //if GeoIPCity.dat file exists
-    $record = geoip_record_by_name($ip);
-    if(!empty($record))
-    {
-        $countryCode = $record['country_code'];
-        $countryName = $record['country_name'];
-        $country = $countryCode != false  ? $countryCode : 'unknown';
-        $country = $countryName != false  ? $countryName : 'NA';
-    }
+    //if GeoIPCity.dat file exists
+    $record = geoip_record_by_name($ip);
+    if(!empty($record))
+    {
+        $countryCode = $record['country_code'];
+        $countryName = $record['country_name'];
+        $country = $countryCode != false  ? $countryCode : 'unknown';
+        $country = $countryName != false  ? $countryName : 'NA';
+    }
 }
 ```
 
-Theese changes were also made in the latest version of Dotkernel. You should use this fix only if you don't intend to use GeoIP City.
+These changes were also made in the latest version of Dotkernel.
+Use this fix only if you don't intend to use GeoIP City.
 
-We recommend special coding for using GeoIP City and in the GeoIP extension in general.
+## Recommendation
 
-Note that GeoIP is an obsolete extension, Maxmind recommends using GeoIP2.
+Special coding is recommended for using GeoIP City and the GeoIP extension in general.
+Note that GeoIP is an obsolete extension - MaxMind recommends using GeoIP2 instead.
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel/geoip-ip-address-location-in-dotkernel.md b/public/md-articles/dotkernel/geoip-ip-address-location-in-dotkernel.md
index 312c00eb..54ba62f7 100644
--- a/public/md-articles/dotkernel/geoip-ip-address-location-in-dotkernel.md
+++ b/public/md-articles/dotkernel/geoip-ip-address-location-in-dotkernel.md
@@ -11,35 +11,23 @@ language: "en"
 # GeoIP: Ip Address Location In Dotkernel
 
 ## TL;DR
+
 GeoIP is MaxMind's proprietary technology for IP geolocation.
 Dotkernel uses it to get user statistics by country, determining a visitor's country, region, city, postal code, or area code in real time.
 The logic lives in `library/Dot/Geoip.php`, inside the `getCountryByIp` function, which branches over four cases depending on whether the `mod_geoip` PECL extension and its `.dat` files are available.
 
-***GeoIP*** is the proprietary technology that drives [MaxMind's](http://www.maxmind.com/app/ip-location) IP geolocation data and services. It is a non-invasive way to determine geographical and other information about Internet visitors in real-time. When a person visits your website, ***GeoIP*** can determine which country, region, city, postal code, area code the visitor is coming from.
-
-Dotkernel uses ***GeoIP*** to get user statistics by country. The main file for ***GeoIP*** is [library/Dot/Geoip.php](http://websvn.dotkernel.net/filedetails.php?repname=Dotkernel&path=%2Ftrunk%2Flibrary%2FDot%2FGeoip.php) Let’s explain what function ***getCountryByIp*** does:
-
-- Line 41: get session variable to memorize the possible error messages later.
-- Line 42: initialize country with ‘unknown’ value, in case the country isn’t found.
-
-Next there are 4 ***if/else*** statements: **1.** Line 43 – 57: ***mod_geoip*** PECL extension is not installed
-
-- In this case we use the already existing file **externals/geoip/GeoIP.dat** from Dotkernel (If you don’t have it, download it from [here](http://www.maxmind.com/app/geolitecountry)).
-
-**2.** Line 58 – 63: ***mod_geoip*** is installed and ***GeoIP.dat*** file exists on the server: *geoip_db_avail(GEOIP_COUNTRY_EDITION)*
-
-- In this case we simply use the default PHP functions ***[geoip_country_code_by_name](http://php.net/manual/en/book.geoip.php)*** and ***[geoip_country_name_by_name](http://php.net/manual/en/book.geoip.php)*** to get the country code and name.
+## What getCountryByIp does
 
-**3.** Line 64 – 73 : ***mod_geoip*** is installed, ***GeoIP.dat*** file does not exist, but ***GeoIpCity.dat*** exists
+The function first reads the session variable used to remember possible error messages, and initializes the country as 'unknown' in case it isn't found.
+It then runs through four if/else branches:
 
-- In this case we use the PHP function ***[geoip_record_by_name](http://php.net/manual/en/book.geoip.php)*** to get the country code and name.
+1. **`mod_geoip` PECL extension is not installed** - it uses the existing `externals/geoip/GeoIP.dat` file bundled with Dotkernel (downloadable from MaxMind if you don't have it).
+2. **`mod_geoip` is installed and `GeoIP.dat` exists** (`geoip_db_avail(GEOIP_COUNTRY_EDITION)`) - it uses the built-in PHP functions `geoip_country_code_by_name` and `geoip_country_name_by_name` to get the country code and name.
+3. **`mod_geoip` is installed, `GeoIP.dat` doesn't exist, but `GeoIpCity.dat` exists** - it uses the PHP function `geoip_record_by_name` to get the country code and name.
+4. **`mod_geoip` is installed, but neither `GeoIP.dat` nor `GeoIPCity.dat` exist** - same behavior as case 1: it uses `externals/geoip/GeoIP.dat` from the Dotkernel framework.
 
-**4.** Line 74 – 88 : ***mod_geoip*** is installed, but neither GeoIP.dat or GeoIPCity.dat exist
-
-- This has the same behavior like item #1in this list –  it uses ***externals/geoip/GeoIP.dat*** from the Dotkernel framework
-
-```
- line="32">/**
+```php
+/**
  * Get the country by IP
  * Return an array with : short name, like 'us' and long name, like 'United States'
  * @access public
@@ -92,19 +80,19 @@ public function getCountryByIp($ip)
         }
         else
         {
-            $session->message['txt'] = $this->option->warningMessage->modGeoIp;;
+            $session->message = $this->option->warningMessage->modGeoIp;;
             $session->message = 'warning';
         }
     }
     return $country;
 }
-}
 ```
 
 ## FAQ
 
 **Q: What is GeoIP and what does it let Dotkernel do?**
-A: GeoIP is MaxMind's proprietary technology for IP geolocation data. Dotkernel uses it to get user statistics by country, determining a visitor's country, region, city, postal code, or area code in real time.
+A: GeoIP is MaxMind's proprietary technology for IP geolocation data.
+Dotkernel uses it to get user statistics by country, determining a visitor's country, region, city, postal code, or area code in real time.
 
 **Q: Where does the GeoIP logic live in Dotkernel?**
 A: In library/Dot/Geoip.php, inside the getCountryByIp function.
@@ -116,4 +104,12 @@ A: It falls back to the existing externals/geoip/GeoIP.dat file bundled with Dot
 A: It uses the built-in PHP functions geoip_country_code_by_name and geoip_country_name_by_name to get the country code and name.
 
 **Q: What if GeoIP.dat is missing but GeoIPCity.dat exists, or neither file exists?**
-A: If GeoIPCity.dat exists, it uses the PHP function geoip_record_by_name to get the country code and name. If neither .dat file exists, it behaves the same as when mod_geoip isn't installed, falling back to externals/geoip/GeoIP.dat.
+A: If GeoIPCity.dat exists, it uses the PHP function geoip_record_by_name to get the country code and name.
+If neither .dat file exists, it behaves the same as when mod_geoip isn't installed, falling back to externals/geoip/GeoIP.dat.
+
+## Resources
+
+- [MaxMind's IP geolocation](http://www.maxmind.com/app/ip-location)
+- [library/Dot/Geoip.php source](http://websvn.dotkernel.net/filedetails.php?repname=Dotkernel&path=%2Ftrunk%2Flibrary%2FDot%2FGeoip.php)
+- [GeoLite Country database](http://www.maxmind.com/app/geolitecountry)
+- [PHP GeoIP functions](http://php.net/manual/en/book.geoip.php)
diff --git a/public/md-articles/dotkernel/handling-and-logging-errors-with-dot-errorhandler-and-dot-log.md b/public/md-articles/dotkernel/handling-and-logging-errors-with-dot-errorhandler-and-dot-log.md
index bca9a7fa..1fb59d1a 100644
--- a/public/md-articles/dotkernel/handling-and-logging-errors-with-dot-errorhandler-and-dot-log.md
+++ b/public/md-articles/dotkernel/handling-and-logging-errors-with-dot-errorhandler-and-dot-log.md
@@ -11,105 +11,70 @@ language: "en"
 # Handling and Logging errors with dot-errorhandler and dot-log
 
 ## TL;DR
+
 This article is a follow-up to "Logging with dot-log in Zend Expressive and Dotkernel" and explains how to use `dotkernel/dot-errorhandler` together with `dotkernel/dot-log` or `zendframework/zend-log` to log errors in Zend Expressive applications.
 It covers how dot-errorhandler was built, how to configure it, and how it was tested.
 
-This article is a follow-up for: **[Logging with dot-log in Zend Expressive and Dotkernel](https://www.dotkernel.com/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel/)**, the mentioned article is a guide to using dot-log.
-
- 
-
-This article explains the usage of **dotkernel/dot-errorhandler** with **dotkernel/dot-log** or **zendframework/zend-log** to **log errors** in Zend Expressive applications.
-
-This can be considered as a guide on how the **dot-errorhandler** was made and how it's meant to be used.
-
- 
-
-As a first note Dot Error Handler provides two kinds of error handlers:
+## The two error handlers
 
-- the plain `ErrorHandler` - this class is a copy of Zend Expressive's error handler `Zend\Stratigility\Middleware\ErrorHandler` (as it is final)
-- the logging `LogErrorHandler` - this class is like the above one, but with added Logging support (via container)
+- **The plain `ErrorHandler`** - a copy of Zend Expressive's `Zend\Stratigility\Middleware\ErrorHandler` (copied because that class is `final`).
+- **The logging `LogErrorHandler`** - the same as above, but with added logging support via the container.
 
-Both error handlers have factories for an easier usage with the **Container**.
+Both error handlers have factories registered for easier use with the Container.
 
- 
+Install it with:
 
-To use dot-error handler in your project run the following command: `composer require dotkernel/dot-errorhandler`.
-
- 
-
-## The Config Provider
-
-When the dot-errorhandler config provider is invoked the following configuration is returned.
-
-```
-,
-        'factories' =>
-    ],
-];
+```shell
+composer require dotkernel/dot-errorhandler
 ```
 
-Both the error handlers have the factories registered, and an alias to switch between them is added.
-
-As a fallback case the plain error handler is selected by default and can be overwritten through the config file.
+## The Config Provider
 
- 
+When the dot-errorhandler config provider is invoked, both error handlers' factories are registered, and an alias is added to switch between them.
+As a fallback, the plain error handler is selected by default, and this can be overwritten through the config file.
 
 ## Configuration
 
-**IMPORTANT NOTES:**
-
-- Assuming the project in hand has a configured logger as per **[this article](https://www.dotkernel.com/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel/)** and the logger name is **default_logger** (as provided in the package's config example).
-- Although the key is `dot_log`, when selecting a logger the dot log abstract factory responds to the `dot-log` selector
-  - to select the container key asked for is `dot-log.default_logger`
-- The dot-errorhandler was meant as a silent logger for staging and production environments doesn't block whoops
-  - to test it the development mode should be **disabled**, otherwise whoops will catch the errors and show them to the developer
-  - you can use any custom implemented error handler as long as it implements the provided `ErrorHandlerInterface`
+Important notes:
 
-The steps to configuring are the following:
+- This assumes the project already has a configured logger, as described in the "Logging with dot-log in Zend Expressive and Dotkernel" article, with the logger named `default_logger` (as used in the package's config example).
+- Although the config key is `dot_log`, the dot-log abstract factory responds to the `dot-log` selector - the container key to ask for is `dot-log.default_logger`.
+- dot-errorhandler is meant to be a silent logger for staging and production environments.
+To test it, development mode should be disabled, otherwise whoops will catch the errors and show them to the developer instead.
+Any custom error handler can be used as long as it implements the provided `ErrorHandlerInterface`.
 
-- add the `Dot\ErrorHandler\ConfigProvider` in the project's `config/config.php` file
-- write the error handler config
+Steps to configure:
 
- 
+1. Add `Dot\ErrorHandler\ConfigProvider` to the project's `config/config.php` file.
+2. Write the error handler config.
 
-To use the logging error handler the following config must be used.
+To use the logging error handler, this config is needed, in `config/autoload/dot-errorhandler.global.php`:
 
- 
-
-`config/autoload/dot-errorhandler.global.php`
-
-```
+```php
 use Dot\ErrorHandler\ErrorHandlerInterface;
 use Dot\ErrorHandler\LogErrorHandler;
-
-return
-    ],
-    'dot-errorhandler' =>
-];
 ```
 
-The **logger** key in dot-error handler should reflect your logger configuration in `config/autoload/log.global.php`
-
-To use the default logger an out-of-the-box config was provided within the error handler's config directory.
+The `logger` key in the dot-errorhandler config should reflect your logger configuration in `config/autoload/log.global.php`.
+An out-of-the-box config was provided within the error handler's config directory for using the default logger.
 
 ## Usage / Triggering errors
 
-The tests we have made were the following:
-
-- throwing Exceptions - the most common
-- raising errors such as triggering warning/error messages:
-  - by dividing numbers to zero (eg.: **16/0**)
-  - by casting arrays to strings (**$string = 'hello' . ['world']['dot_log']['world']**)
+Errors were triggered in the following ways to test the handlers:
 
- 
+- Throwing Exceptions - the most common case.
+- Raising errors, such as triggering warning/error messages, for example:
+  - dividing numbers by zero (e.g. `16/0`)
+  - casting arrays to strings (e.g. `$string = 'hello' . $array`)
 
 ## FAQ
 
 **Q: What two kinds of error handlers does dot-errorhandler provide?**
-A: A plain ErrorHandler, which is a copy of Zend Expressive's Zend\Stratigility\Middleware\ErrorHandler (copied because that class is final), and a logging LogErrorHandler, which is the same but with added logging support via the container. Both have factories registered for easier use with the Container.
+A: A plain ErrorHandler, which is a copy of Zend Expressive's Zend\Stratigility\Middleware\ErrorHandler (copied because that class is final), and a logging LogErrorHandler, which is the same but with added logging support via the container.
+Both have factories registered for easier use with the Container.
 
 **Q: How do you install dot-errorhandler?**
-A: Run composer require dotkernel/dot-errorhandler.
+A: Run `composer require dotkernel/dot-errorhandler`.
 
 **Q: Which error handler is used by default?**
 A: The plain error handler is selected by default as a fallback, and this can be overwritten through the config file, which also registers factories for both handlers plus an alias to switch between them.
@@ -118,7 +83,12 @@ A: The plain error handler is selected by default as a fallback, and this can be
 A: A configured logger as described in the "Logging with dot-log in Zend Expressive and Dotkernel" article, with the logger named default_logger as used in the package's config example.
 
 **Q: Why might whoops interfere when testing dot-errorhandler?**
-A: dot-errorhandler is meant to be a silent logger for staging and production environments. To actually test it, development mode should be disabled, otherwise whoops will catch the errors and show them to the developer instead.
+A: dot-errorhandler is meant to be a silent logger for staging and production environments.
+To actually test it, development mode should be disabled, otherwise whoops will catch the errors and show them to the developer instead.
 
 **Q: How were errors triggered to test the error handlers?**
 A: By throwing Exceptions, the most common case, and by raising warnings/errors such as dividing a number by zero (e.g. 16/0) or casting an array to a string.
+
+## Resources
+
+- [Logging with dot-log in Zend Expressive and Dotkernel](https://www.dotkernel.com/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel/)
diff --git a/public/md-articles/dotkernel/highcharts-integration-in-dotkernel-1-6-0.md b/public/md-articles/dotkernel/highcharts-integration-in-dotkernel-1-6-0.md
index e6ec07de..e585e517 100644
--- a/public/md-articles/dotkernel/highcharts-integration-in-dotkernel-1-6-0.md
+++ b/public/md-articles/dotkernel/highcharts-integration-in-dotkernel-1-6-0.md
@@ -11,64 +11,68 @@ language: "en"
 # Highcharts Integration in Dotkernel 1.6.0
 
 ## TL;DR
+
 Dotkernel 1.6.0 integrates the Highcharts charting library, offering a new, intuitive and interactive charting experience.
 Sample charts (pie, column and line) were added to the admin, and the library ships in the project's externals directory.
 
-Integrating a new charting library in the latest version of Dotkernel (1.6.0) we offer a new experience with this new intuitive and interactive charts.
+## What was added
+
+The admin includes samples built with Highcharts:
 
-Also in admin we made some samples using highcharts. These samples includes an pie chart (with a small custom feature), an column chart and the last one is an line chart.
+- A pie chart (with a small custom feature)
+- A column chart
+- A line chart
 
 [![](/uploads/article/019f8a80-cc3b-71e4-913b-5c28321fc438/highcharts-1024x651.png)](/uploads/2012/05/highcharts.png)
 
-You can find highcharts library in the **externals **directory.
+The Highcharts library itself can be found in the **externals** directory of the project.
 
-Take a quick view on the code to see how highcharts are working.
+## Example: line chart configuration
 
-```
+The article shows a sample of how a line chart is configured with Highcharts, including the chart type, tooltip formatter, axis labels and the `timeActivity` series:
+
+```javascript
 chart = new Highcharts.Chart({
-        chart: {
-            renderTo: elementId,
-            type: 'line',
-            plotBackgroundColor: null,
-            plotBorderWidth: 0,
-        },
-        credits: {
-            enabled: false
-        },
+    chart: {
+        renderTo: elementId,
+        type: 'line',
+        plotBackgroundColor: null,
+        plotBorderWidth: 0,
+    },
+    credits: {
+        enabled: false
+    },
+    title: {
+        text: ''
+    },
+    colors: colors,
+    tooltip: {
+        formatter: function() {
+            return '<strong>' + this.series.name + ' ' + this.x + '</strong>' + 'Total logins: ' + this.y;
+        }
+    },
+    yAxis: {
         title: {
-            text: ''
+            text: 'Logins count'
         },
-        colors: colors,
-        tooltip: {
-            formatter: function() {
-                    return '' + this.series.name + ' ' + this.x + '
-' + 'Total logins: ' + this.y;
+        min: 0
+    },
+    xAxis: {
+        categories: ['1','2','3','4','5','6','7','8','9','10','11','12',
+                                 '13','14','15','16','17','18','19','20','21','22',
+                                 '23','24','25','26','27','28','29','30','31'],
+        labels: {
+            rotation: -45,
+            align: 'right',
+            style: {
+                font: 'normal 10px Verdana, sans-serif'
             }
-        },
-        yAxis: {
-            title: {
-                text: 'Logins count'
-            },
-            min: 0
-        },
-        xAxis: {
-            categories: ['1','2','3','4','5','6','7','8','9','10','11','12',
-                                     '13','14','15','16','17','18','19','20','21','22',
-                                     '23','24','25','26','27','28','29','30','31'],
-            labels: {
-                rotation: -45,
-                align: 'right',
-                style: {
-                    font: 'normal 10px Verdana, sans-serif'
-                }
-            }
-        },
-        series: timeActivity
-    });
+        }
+    },
+    series: timeActivity
+});
 ```
 
- 
-
 ## FAQ
 
 **Q: What charting library was integrated in Dotkernel 1.6.0?**
diff --git a/public/md-articles/dotkernel/how-to-group-log-files-by-date-using-dot-log.md b/public/md-articles/dotkernel/how-to-group-log-files-by-date-using-dot-log.md
index 4df7ab0c..282135ac 100644
--- a/public/md-articles/dotkernel/how-to-group-log-files-by-date-using-dot-log.md
+++ b/public/md-articles/dotkernel/how-to-group-log-files-by-date-using-dot-log.md
@@ -14,21 +14,23 @@ language: "en"
 [dot-log](https://github.com/dotkernel/dot-log) is a powerful, easily customizable logging tool.
 [Version 3.1.1](https://github.com/dotkernel/dot-log/releases/tag/3.1.1) adds the ability to use datetime formatter strings right in the stream option of a log writer, and fixes an issue where caching dot-log configs caused logs to be written to a single file instead of being grouped by date.
 
-As described in [this article](https://www.dotkernel.com/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel/), [dot-log](https://github.com/dotkernel/dot-log) is a powerful tool for logging messages in your application. It's power stays in the fact that it can be implemented in a few easy steps and that it's highly customizable.
-
-With a little help from PHP's `date` function, [Version 3.1.1](https://github.com/dotkernel/dot-log/releases/tag/3.1.1) takes this one step further, though. It adds the ability to use datetime formatter strings right in the stream option of your log writer. It also fixes an issue where caching dot-log configs caused logs to be written to the same file, instead of being grouped by date.
-
 ## Prerequisites
 
-You will need dot-log installed and configured inside your application. If it's not installed, you can install it by following the steps described [here](https://www.dotkernel.com/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel/). Else, make sure you're using the latest version of dot-log by running `composer update dotkernel/dot-log`.
+- dot-log installed and configured inside your application.
+If it's not installed, follow the steps in [Logging with dot-log in Zend Expressive and Dotkernel](https://www.dotkernel.com/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel/).
+- Otherwise, make sure you're using the latest version by running:
+
+```shell
+composer update dotkernel/dot-log
+```
 
-As always, we strongly suggest you to keep your packages updated. Allthough, if your application logs messages in a single file with a static name (eg: log/dk.log), you can skip the rest of this article - logging will work as before.
+If your application logs messages to a single file with a static name (e.g. `log/dk.log`), you can skip the rest of this guide - logging will work as before.
 
 ## Configuring the logger with Dotkernel
 
-Your application should already have a **config/autoload/error-handling.global.php** file, similar to this:
+Your application should already have a `config/autoload/error-handling.global.php` file similar to:
 
-```
+```php
 <?php
 
 return [
@@ -67,104 +69,49 @@ return [
 ];
 ```
 
-Inside that file, locate every instance of your log writers by navigating to: `dot_log->loggers->default_logger->writers`. For each writer, you'll find a `stream` option containing the path to your log file. If your `stream` config looks like this:
+1. Locate every log writer by navigating to `dot_log -> loggers -> default_logger -> writers`.
+2. For each writer, find the `stream` option containing the path to the log file.
+If it looks like:
 
-`'stream' => sprintf('%s/../../log/error-log-%s.log', __DIR__, date('Y-m-d'))`
+   ```php
+   'stream' => sprintf('%s/../../log/error-log-%s.log', __DIR__, date('Y-m-d'))
+   ```
 
-replace it with:
+3. Replace it with:
 
-`'stream' => __DIR__ . '/../../log/error-log-{Y}-{m}-{d}.log'`
+   ```php
+   'stream' => __DIR__ . '/../../log/error-log-{Y}-{m}-{d}.log'
+   ```
 
-The last step is to clear config cache using the command:
+4. Clear the config cache:
 
-`php bin/clear-config-cache.php`
+   ```shell
+   php bin/clear-config-cache.php
+   ```
 
-If the path to your log files contains other date format specifiers, make sure you adapt it accordingly. A complete list of the specifiers can be found [here](https://www.php.net/manual/en/datetime.format.php).
+If the log path uses other date format specifiers, adapt them accordingly - the full list is in the [PHP date() manual](https://www.php.net/manual/en/datetime.format.php).
 
 ## Configuring the logger without Dotkernel
 
-Locate dot-log configs in your application (probably /config/autoload/log.global.php). They should look similar to this:
-
-```
-<?php
-
-return [
-    'dot_log' => [
-        'loggers' => [
-            'my_logger' => [
-                'writers' => [
-                    'FileWriter' => [
-                        'name' => 'FileWriter',
-                        'priority' => \Laminas\Log\Logger::ALERT,
-                        'options' => [
-                            'stream' => __DIR__ . '/../../log/dk.log',
-                            'filters' => [
-                                'allMessages' => [
-                                    'name' => 'priority',
-                                    'options' => [
-                                        'operator' => '>=',
-                                        'priority' => \Laminas\Log\Logger::EMERG,
-                                    ]
-                                ],
-                            ],
-                        ],
-                    ],
-                    // Only warnings
-                    'OnlyWarningsWriter' => [
-                        'name' => 'stream',
-                        'priority' => \Laminas\Log\Logger::ALERT,
-                        'options' => [
-                            'stream' => __DIR__ . '/../../log/warnings_only.log',
-                            'filters' => [
-                                'warningOnly' => [
-                                    'name' => 'priority',
-                                    'options' => [
-                                        'operator' => '==',
-                                        'priority' => \Laminas\Log\Logger::WARN,
-                                    ],
-                                ],
-                            ],
-                        ],
-                    ],
-                    // Warnings and more important messages
-                    'WarningOrHigherWriter' => [
-                        'name' => 'stream',
-                        'priority' => \Laminas\Log\Logger::ALERT,
-                        'options' => [
-                            'stream' => __DIR__ . '/../../log/important_messages.log',
-                            'filters' => [
-                                'importantMessages' => [
-                                    'name' => 'priority',
-                                    'options' => [
-                                        // note, the smaller the priority, the more important is the message
-                                        // 0 - emergency, 1 - alert, 2- error, 3 - warn. .etc
-                                        'operator' => '<=',
-                                        'priority' => \Laminas\Log\Logger::WARN,
-                                    ],
-                                ],
-                            ],
-                        ],
-                    ],
-                ],
-            ],
-        ],
-    ],
-];
-```
+Locate the dot-log config (probably `/config/autoload/log.global.php`), which should look similar to the Dotkernel example but keyed under a custom logger name (e.g. `my_logger`) and may define multiple writers (e.g. a general file writer, a warnings-only writer, and a warnings-or-higher writer).
 
-Inside that file, locate every instance of your log writers by navigating to: `dot_log->loggers->my_logger->writers`. For each writer, you'll find a `stream` option containing the path to your log file. If your `stream` config looks like this:
+1. Locate every writer by navigating to `dot_log -> loggers -> my_logger -> writers`.
+2. For each writer, find the `stream` option.
+If it looks like:
 
-`'stream' => sprintf('%s/../../log/dk-%s.log', __DIR__, date('Y-m-d'))`
+   ```php
+   'stream' => sprintf('%s/../../log/dk-%s.log', __DIR__, date('Y-m-d'))
+   ```
 
-replace it with:
+3. Replace it with:
 
-```
-'stream' => __DIR__ . '/../../log/error-log-{Y}-{m}-{d}.log',
-```
+   ```php
+   'stream' => __DIR__ . '/../../log/error-log-{Y}-{m}-{d}.log',
+   ```
 
-If the path to your log files contains other date format specifiers, make sure you adapt it accordingly. A complete list of the specifiers can be found [here](https://www.php.net/manual/en/datetime.format.php).
+4. Make sure you clear your application's config before usage.
 
-Make sure you clear your application's config before usage.
+As before, adapt any other date format specifiers as needed - see the [PHP date() manual](https://www.php.net/manual/en/datetime.format.php).
 
 ## FAQ
 
@@ -172,16 +119,24 @@ Make sure you clear your application's config before usage.
 A: Version 3.1.1 adds the ability to use datetime formatter strings directly in the stream option of your log writer, and it fixes an issue where caching dot-log configs caused logs to be written to the same file instead of being grouped by date.
 
 **Q: How do I make sure I'm using the fix in Version 3.1.1?**
-A: Make sure you're using the latest version of dot-log by running composer update dotkernel/dot-log.
+A: Make sure you're using the latest version of dot-log by running `composer update dotkernel/dot-log`.
 
 **Q: Do I need to change anything if my logs are already written to a single static file?**
 A: No. If your application logs messages in a single file with a static name (e.g. log/dk.log), you can skip the rest of the article - logging will work as before.
 
 **Q: How do I group log files by date when using Dotkernel?**
-A: In config/autoload/error-handling.global.php, locate every log writer by navigating to dot_log->loggers->default_logger->writers and replace a stream value like sprintf('%s/../../log/error-log-%s.log', __DIR__, date('Y-m-d')) with __DIR__ . '/../../log/error-log-{Y}-{m}-{d}.log'.
+A: In `config/autoload/error-handling.global.php`, locate every log writer by navigating to `dot_log->loggers->default_logger->writers` and replace a stream value like `sprintf('%s/../../log/error-log-%s.log', __DIR__, date('Y-m-d'))` with `__DIR__ . '/../../log/error-log-{Y}-{m}-{d}.log'`.
 
 **Q: How do I group log files by date without Dotkernel?**
-A: In your dot-log config (e.g. /config/autoload/log.global.php), locate every writer under dot_log->loggers->my_logger->writers and replace a dynamic stream value such as sprintf('%s/../../log/dk-%s.log', __DIR__, date('Y-m-d')) with a formatter string like __DIR__ . '/../../log/error-log-{Y}-{m}-{d}.log'.
+A: In your dot-log config (e.g. `/config/autoload/log.global.php`), locate every writer under `dot_log->loggers->my_logger->writers` and replace a dynamic stream value with a formatter string using `{Y}-{m}-{d}` placeholders.
 
 **Q: What must I do after changing the stream configuration?**
-A: Clear the config cache. In a Dotkernel application, run php bin/clear-config-cache.php; in a non-Dotkernel setup, make sure you clear your application's config before usage.
+A: Clear the config cache.
+In a Dotkernel application, run `php bin/clear-config-cache.php`; in a non-Dotkernel setup, make sure you clear your application's config before usage.
+
+## Resources
+
+- [dot-log on GitHub](https://github.com/dotkernel/dot-log)
+- [dot-log Version 3.1.1 release notes](https://github.com/dotkernel/dot-log/releases/tag/3.1.1)
+- [Logging with dot-log in Zend Expressive and Dotkernel](https://www.dotkernel.com/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel/)
+- [PHP date() format specifiers](https://www.php.net/manual/en/datetime.format.php)
diff --git a/public/md-articles/dotkernel/how-to-set-a-persistent-connection-to-database-with-zend-framework-zend-db-adapter.md b/public/md-articles/dotkernel/how-to-set-a-persistent-connection-to-database-with-zend-framework-zend-db-adapter.md
index 4a334a66..0278cce4 100644
--- a/public/md-articles/dotkernel/how-to-set-a-persistent-connection-to-database-with-zend-framework-zend-db-adapter.md
+++ b/public/md-articles/dotkernel/how-to-set-a-persistent-connection-to-database-with-zend-framework-zend-db-adapter.md
@@ -10,21 +10,18 @@ language: "en"
 
 # How to Set a Persistent Connection to Database with Zend Framework Zend_Db adapter
 
-From time to time, it may be a good idea to have a persistent connection to database.
+From time to time, it may be a good idea to have a persistent connection to the database.
+The configuration option should be added to `application.ini` (using Dotkernel as an example).
 
-The place where it should be added that new configuration option is application.ini ( Dotkernel approach as an example)
+Do **not** use the following - it will not work:
 
-Do **not** try something like below, will not work:
-
-```
+```ini
 database.params.options.PDO::ATTR_PERSISTENT = TRUE
 ```
 
- 
+Instead, use this line:
 
-Instead , use the below line
-
-```
+```ini
 database.params.persistent = TRUE
 ```
 
@@ -34,7 +31,7 @@ database.params.persistent = TRUE
 A: The option should be added in application.ini, as shown in the Dotkernel approach used as an example in the article.
 
 **Q: What Zend_Db configuration line should NOT be used for a persistent connection?**
-A: database.params.options.PDO::ATTR_PERSISTENT = TRUE should not be used - the article states that it will not work.
+A: `database.params.options.PDO::ATTR_PERSISTENT = TRUE` should not be used - the article states that it will not work.
 
 **Q: What's the correct line to enable a persistent connection?**
-A: Use database.params.persistent = TRUE instead.
+A: Use `database.params.persistent = TRUE` instead.
diff --git a/public/md-articles/dotkernel/how-to-use-alerts-in-dotkernel.md b/public/md-articles/dotkernel/how-to-use-alerts-in-dotkernel.md
index e33c294e..82199396 100644
--- a/public/md-articles/dotkernel/how-to-use-alerts-in-dotkernel.md
+++ b/public/md-articles/dotkernel/how-to-use-alerts-in-dotkernel.md
@@ -15,21 +15,25 @@ Alerts (Dot_Alert's) are e-mails usually sent to site developers using PHP's `ma
 Dot_Alert resembles Dot_Email: it has a sender, subject, destination and message, and can be sent.
 This guide walks through Dotkernel's existing example, where an Alert notifies the developer when an e-mail fails to send.
 
-Alerts (or Dot_Alert's) are e-mails usually sent to the site developers, these messages are sent with **mail()** therefore you shouldn't use them to send regular mail. Alerts should only notify you as a developer: "***Hey, something's wrong here, you might want to know this!***"
+## What Dot_Alert is for
 
-In this article you will find out how to use the Alerts system in Dotkernel, we will also go through an existing example so this can be understood easier.
+Alerts should only notify a developer: *"Hey, something's wrong here, you might want to know this!"*
+The Dot_Alert class resembles Dot_Email - like a mail message, an alert has at least a sender, a subject, a destination and a message, and it can be sent.
 
-The Dot_Alert class resembles with Dot_Email, the alerts, like a mail message, have at least the sender, a subject, a destination and a message and it can also be sent.
+## Example: notifying a developer of a failed e-mail send
 
-In Dotkernel we use the Alerts for notifying the developer that an email was not sent successfully.
+In Dotkernel, Alerts are used to notify the developer when an e-mail was not sent successfully.
 
-In this case we kept the message in the dots.xml file
+### 1. The message template (dots.xml)
 
-```
-    
-        
-             SMTP Error on {SITE_NAME} 
-            
+The alert message is kept in the `dots.xml` file:
+
+```xml
+<variable option="global">
+    <alertMessages>
+        <email>
+            <subject> SMTP Error on {SITE_NAME} </subject>
+            <message>
 SMTP Error on {SITE_NAME}
 We were unable to send SMTP email
 ---------------------------------
@@ -39,29 +43,28 @@ To Email: {TO_EMAIL}
 From Email: {FROM_EMAIL}
 Date: {DATE_NOW}
 ---------------------------------
-            
-        
-    
+            </message>
+        </email>
+    </alertMessages>
+</variable>
 ```
 
-If you're not familiar with the dots.xml, you should see [this article](http://www.dotkernel.com/docs/dots-xml/).
-
-First the message will be fetched from the xml file, we already have it in $this->option
+### 2. Fetch the message from the config
 
-```
+```php
 $subject = $this->option->alertMessages->email->subject;
 $message = $this->option->alertMessages->email->message;
 ```
 
-Second, we get the destination recipient (in this case the developers e-mail addresses)
+### 3. Get the destination recipients
 
-```
+```php
 $devEmails = explode(',', $this->settings->devEmails);
 ```
 
-As you can see the Alert messages contains **{VARIABLES}** called details in the Alert system. Now we will prepare the details:
+### 4. Prepare the details that fill the {VARIABLES}
 
-```
+```php
 $details = array(
     'e_class' => get_class($e),
     'site_name' => $this->seoOption->siteName,
@@ -73,45 +76,36 @@ $details = array(
 );
 ```
 
-Note that $e is a caught exception, this exception is thrown when the e-mail send process fails. Now that we have it all, let's create an alert:
+`$e` is the caught exception thrown when the e-mail send process fails.
 
-```
+### 5. Create and send the alert
+
+```php
 $alert = new Dot_Alert();
-```
 
-This is just an empty alert, we will now set the sender, the subject and the message, the sender is set on sending
+$alert->addHeader("From: " . $this->settings->siteEmail);
+$alert->addHeader("Reply-To:" . $this->settings->siteEmail);
+$alert->addHeader("X-Mailer: PHP/" . phpversion());
 
-```
-$alert->addHeader( "From: " . $this->settings->siteEmail);
-$alert->addHeader( "Reply-To:" . $this->settings->siteEmail );
-$alert->addHeader( "X-Mailer: PHP/" . phpversion() ) ;
-```
-
-```
 $alert->setTo($devEmails);
 $alert->setSubject($subject);
 $alert->setContent($message);
-```
 
-Our message doesn't look that good, the setDetails method will replace our **{VARIABLES}** within subject and message with actual data
-
-```
+// replaces the {VARIABLES} in subject/message with real data
 $alert->setDetails($details);
-```
-
-Everything is great, we can now send our alert:
 
-```
 $alert->send();
 ```
 
 ## FAQ
 
 **Q: What is a Dot_Alert used for?**
-A: Alerts (Dot_Alert's) are e-mails usually sent to the site developers using PHP's mail() function. They shouldn't be used to send regular mail - they only notify the developer that something is wrong.
+A: Alerts (Dot_Alert's) are e-mails usually sent to the site developers using PHP's mail() function.
+They shouldn't be used to send regular mail - they only notify the developer that something is wrong.
 
 **Q: What does the Dot_Alert class resemble, and what does an alert contain?**
-A: Dot_Alert resembles Dot_Email. Like a mail message, an alert has at least a sender, a subject, a destination and a message, and it can be sent.
+A: Dot_Alert resembles Dot_Email.
+Like a mail message, an alert has at least a sender, a subject, a destination and a message, and it can be sent.
 
 **Q: What's an example use of Alerts in Dotkernel?**
 A: Dotkernel uses Alerts to notify the developer when an email was not sent successfully, with the message kept in the dots.xml file under the alertMessages section.
@@ -121,3 +115,7 @@ A: A $details array is prepared (e.g. e_class, site_name, site_url, e_message, t
 
 **Q: What are the steps to build and send an alert?**
 A: Create a new Dot_Alert(), add headers such as From, Reply-To and X-Mailer, then call setTo(), setSubject() and setContent(), then setDetails() to fill in the placeholders, and finally call send().
+
+## Resources
+
+- [Understanding dots.xml](http://www.dotkernel.com/docs/dots-xml/)
diff --git a/public/md-articles/dotkernel/implementing-the-new-password-hashing-api-from-php-5-5-in-dotkernel.md b/public/md-articles/dotkernel/implementing-the-new-password-hashing-api-from-php-5-5-in-dotkernel.md
index 8781dda7..17851597 100644
--- a/public/md-articles/dotkernel/implementing-the-new-password-hashing-api-from-php-5-5-in-dotkernel.md
+++ b/public/md-articles/dotkernel/implementing-the-new-password-hashing-api-from-php-5-5-in-dotkernel.md
@@ -14,38 +14,24 @@ language: "en"
 To use the new [Password Hashing](http://www.php.net/manual/en/book.password.php) functions introduced in PHP 5.5 and unify password-related functions for both admin and users, Dotkernel's codebase was refactored in version 1.8.0 (starting from revision 799).
 Because those functions require PHP 5.5+, the [Password Compat library](https://github.com/ircmaxell/password_compat) is used for compatibility, and the minimum PHP version to run Dotkernel was raised to 5.3.8.
 
-In order to use the new [Password Hashing](http://www.php.net/manual/en/book.password.php) functions , introduced in PHP 5.5 , and unify all password related functions , used for both admin and users, we did a major refactor of Dotkernel codebase, in version 1.8.0 , starting from revision 799.
+## Background
 
-See more on that matter[here](http://www.brandonsavage.net/please-stop-hashing-passwords-yourself/)
+See more on the reasoning behind this change [here](http://www.brandonsavage.net/please-stop-hashing-passwords-yourself/).
 
-Since those 4 new functions are available only since PHP 5.5 , we used the [Password Compatibility library.](https://github.com/ircmaxell/password_compat)
+## Applying this refactor to older Dotkernel systems
 
-The minimum PHP version in order to run Dotkernel was raised to PHP 5.3.8 .
+1. Change the table structure to handle the new password format:
 
- 
+   ```sql
+   ALTER TABLE `admin` CHANGE `password` `password` VARCHAR(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL;
+   ALTER TABLE `user` CHANGE `password` `password` VARCHAR(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL;
+   ```
 
-**How to apply this refactor to older Dotkernel systems**
-
-```
-ALTER TABLE `admin` CHANGE `password` `password` VARCHAR(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL;
-```
-
-```
-ALTER TABLE `user` CHANGE `password` `password` VARCHAR(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL;
-```
-
-- Remove from application.ini the variable **settings.admin.salt = 5F6WQ9U3YT**
-- apply the patch . [Download](http://www.dotkernel.com/download/?did=40)
-- if you have trouble applying the patch, you can compare the files and see the log/diff in [websvn](http://websvn.dotkernel.net/comp.php?repname=Dotkernel&compare[]=/@796&compare[]=/@797)
-- run the conversion script . You can find the details in the file Console/Controller.php , at line 47
-- Hope that you will not break something :-)
-- Admin passwords cannot be converted , so need to be recreated manually .
-
- 
-
- 
-
- 
+2. Remove the `settings.admin.salt = 5F6WQ9U3YT` variable from `application.ini`.
+3. Apply the [patch](http://www.dotkernel.com/download/?did=40).
+4. If you have trouble applying the patch, compare the files and see the log/diff in [websvn](http://websvn.dotkernel.net/comp.php?repname=Dotkernel&compare[]=/@796&compare[]=/@797).
+5. Run the conversion script - details are in the file `Console/Controller.php`, at line 47.
+6. Admin passwords cannot be converted, so they need to be recreated manually.
 
 ## FAQ
 
@@ -63,3 +49,11 @@ A: Change the password column definition in the admin and user tables via ALTER
 
 **Q: What happens to existing admin passwords during the upgrade?**
 A: Admin passwords cannot be converted automatically, so they need to be recreated manually.
+
+## Resources
+
+- [PHP Password Hashing manual](http://www.php.net/manual/en/book.password.php)
+- [Please stop hashing passwords yourself](http://www.brandonsavage.net/please-stop-hashing-passwords-yourself/)
+- [Password Compatibility library](https://github.com/ircmaxell/password_compat)
+- [Patch download](http://www.dotkernel.com/download/?did=40)
+- [websvn diff (revision 796 vs 797)](http://websvn.dotkernel.net/comp.php?repname=Dotkernel&compare[]=/@796&compare[]=/@797)
diff --git a/public/md-articles/dotkernel/installing-geoip-extension-in-zend-server-5-6-on-windows.md b/public/md-articles/dotkernel/installing-geoip-extension-in-zend-server-5-6-on-windows.md
index 169b7b01..21567f8a 100644
--- a/public/md-articles/dotkernel/installing-geoip-extension-in-zend-server-5-6-on-windows.md
+++ b/public/md-articles/dotkernel/installing-geoip-extension-in-zend-server-5-6-on-windows.md
@@ -13,53 +13,59 @@ language: "en"
 ## TL;DR
 Test whether php_geoip is already available, and if not, download the correct php_geoip.dll for your PHP build from windows.php.net, copy it into Zend Server's phpext folder, enable it from the Zend Server GUI, and download the MaxMind GeoIP databases.
 
-To test if you have php_geoip extension on your Zend Server, create an php file and copy the following code. This will output true if extension is available or false if not.
+## Steps
 
-```
-If your output is false than you have to download an php_geoip.dll file correctly compiled for your zend server version.
+1. Test if you have the php_geoip extension:
 
-For Zend Server 5.6 you can find geoip extension here:
+   ```php
+   <?php
+   var_dump(function_exists('geoip_database_info'));
+   ```
 
-http://windows.php.net/downloads/pecl/releases/geoip/1.0.8/
+   This outputs `true` if the extension is available, or `false` if not.
 
-As you can see there are several files for different architectures and compilers
+2. If the output is `false`, download a php_geoip.dll file correctly compiled for your Zend Server version from [http://windows.php.net/downloads/pecl/releases/geoip/1.0.8/](http://windows.php.net/downloads/pecl/releases/geoip/1.0.8/).
+There are several files for different architectures and compilers.
 
-** NOTE: you can find on what architecture your php is built and the compiler used with phpinfo();
+3. Find your PHP's architecture and compiler by running `phpinfo();`.
+Example values:
 
-Compiler
-MSVC9 (Visual C++ 2008)
+   | Field | Value |
+   |---|---|
+   | Compiler | MSVC9 (Visual C++ 2008) |
+   | Architecture | x86 |
 
-Architecture
-x86
+4. Copy the downloaded `php_geoip.dll` file into:
 
-After you have downloaded the php_geoip.dll you have to copy the file in:
+   ```
+   C:\YOUR_LOCATION\Zend\ZendServer\lib\phpext\
+   ```
 
-C:\YOUR_LOCATION\Zend\ZendServer\lib\phpext\
+5. In the Zend Server interface, restart PHP, turn on the geoip extension from **Server Setup -> Extension**, and restart PHP again.
 
-Now you have to go in your Zend Server interface, restart php, turn on geoip extension from Server Setup -> Extension and restart php again.
+   If you get an error loading the geoip extension, you picked the wrong dll - try one of the others.
 
-If you get an error loading geoip extension than you picked the wrong dll and you have to try the other ones.
+   Otherwise, the extension is loaded and the test script from step 1 will output `true`.
 
-Otherwise your geoip extension is loaded and your test script from the beginning will output "true".
+6. Download GeoIP databases from MaxMind, as needed:
+   - geoIP.dat
+   - geoIPCity.dat
+   - geoIPOrganization.dat
+   - or anything else you need
 
-The next step is to download some geoip databases from maxmind.
-```
+7. Copy those `.dat` files into:
 
-- geoIP.dat
-- geoIPCity.dat
-- geoIPOrganization.dat
-- or anything you need
+   ```
+   C:\YOUR_LOCATION\Zend\ZendServer\bin\
+   ```
 
-Copy those .dat files in
-
-C:\YOUR_LOCATION\Zend\ZendServer\bin\
-
-And now you can use geoip functions on your Zend Server 5.6
+You can now use geoip functions on Zend Server 5.6.
 
 ## FAQ
 
 **Q: How do you test if the php_geoip extension is available on Zend Server?**
-A: Create a PHP file with var_dump(function_exists('geoip_database_info'));. It outputs true if the extension is available, or false if it isn't.
+A: Create a PHP file with `var_dump(function_exists('geoip_database_info'));`.
+It outputs true if the extension is available, or false if it isn't.
 
 **Q: Where can you download the php_geoip extension for Zend Server 5.6?**
 A: From http://windows.php.net/downloads/pecl/releases/geoip/1.0.8/, where several php_geoip.dll files are available for different architectures and compilers.
@@ -71,7 +77,12 @@ A: You can find your PHP's architecture and the compiler it was built with by ru
 A: Into C:\YOUR_LOCATION\Zend\ZendServer\lib\phpext\.
 
 **Q: How do you enable the geoip extension after copying the dll?**
-A: Go into the Zend Server interface, restart PHP, turn on the geoip extension from Server Setup -> Extension, and restart PHP again. If you get an error loading the extension, you picked the wrong dll and should try another one.
+A: Go into the Zend Server interface, restart PHP, turn on the geoip extension from Server Setup -> Extension, and restart PHP again.
+If you get an error loading the extension, you picked the wrong dll and should try another one.
 
 **Q: What else is needed besides the extension itself?**
 A: You also need to download geoip databases from MaxMind, such as geoIP.dat, geoIPCity.dat, and geoIPOrganization.dat, and copy those .dat files into C:\YOUR_LOCATION\Zend\ZendServer\bin\.
+
+## Resources
+
+- [php_geoip 1.0.8 downloads](http://windows.php.net/downloads/pecl/releases/geoip/1.0.8/)
diff --git a/public/md-articles/dotkernel/installing-geoip-extension-in-zend-server-6-on-windows.md b/public/md-articles/dotkernel/installing-geoip-extension-in-zend-server-6-on-windows.md
index 601743c7..75a405ca 100644
--- a/public/md-articles/dotkernel/installing-geoip-extension-in-zend-server-6-on-windows.md
+++ b/public/md-articles/dotkernel/installing-geoip-extension-in-zend-server-6-on-windows.md
@@ -13,14 +13,19 @@ language: "en"
 ## TL;DR
 As an update to [Installing GeoIP extension in Zend Server 5.6 on Windows](https://www.dotkernel.com/dotkernel/installing-geoip-extension-in-zend-server-5-6-on-windows/), here's how to enable php_geoip on Zend Server 6.1.
 
-As an update to the post [Installing GeoIP extension in Zend Server 5.6 on Windows ](http://www.dotkernel.com/dotkernel/installing-geoip-extension-in-zend-server-5-6-on-windows/), for Zend Server 6.1 , you can do the following:
+## Steps
 
-1. Download the php_geoip-1.0.8-5.4-nts-vc9-x86.zip file from [http://windows.php.net/downloads/pecl/releases/geoip/1.0.8/](http://windows.php.net/downloads/pecl/releases/geoip/1.0.8/)
-2. From the archived file, copy the file php_geoip.dll to ZEND_PATH\Zend\ZendServer\lib\phpext\
-3.  Open php.ini file, from the location: ZEND_PATH\Zend\ZendServer\etc\php.ini
-4.  Add the below line at the end of the file **extension=php_geoip.dll**
-5. Save the file and "Restart PHP" :-))  from Zend Server GUI
-6. follow the step from the previous article in order to test GeoIP integration , and download the Geoip*.dat files
+1. Download the `php_geoip-1.0.8-5.4-nts-vc9-x86.zip` file from [http://windows.php.net/downloads/pecl/releases/geoip/1.0.8/](http://windows.php.net/downloads/pecl/releases/geoip/1.0.8/).
+2. From the archive, copy `php_geoip.dll` to `ZEND_PATH\Zend\ZendServer\lib\phpext\`.
+3. Open the `php.ini` file, located at `ZEND_PATH\Zend\ZendServer\etc\php.ini`.
+4. Add the following line at the end of the file:
+
+   ```ini
+   extension=php_geoip.dll
+   ```
+
+5. Save the file and click **"Restart PHP"** from the Zend Server GUI.
+6. Follow the steps from the previous article to test the GeoIP integration and download the Geoip*.dat files.
 
 ## FAQ
 
@@ -35,3 +40,8 @@ A: Open the php.ini file at ZEND_PATH\Zend\ZendServer\etc\php.ini, add the line
 
 **Q: How do you verify GeoIP is working after this setup?**
 A: Follow the same steps described in the previous article (Installing GeoIP extension in Zend Server 5.6 on Windows) to test the GeoIP integration and download the Geoip*.dat files.
+
+## Resources
+
+- [Installing GeoIP extension in Zend Server 5.6 on Windows](http://www.dotkernel.com/dotkernel/installing-geoip-extension-in-zend-server-5-6-on-windows/)
+- [php_geoip 1.0.8 downloads](http://windows.php.net/downloads/pecl/releases/geoip/1.0.8/)
diff --git a/public/md-articles/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel.md b/public/md-articles/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel.md
index 09c5be8c..6cd93445 100644
--- a/public/md-articles/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel.md
+++ b/public/md-articles/dotkernel/logging-with-dot-log-in-zend-expressive-and-dotkernel.md
@@ -15,240 +15,98 @@ This article explains how to use the [dot-log](https://github.com/dotkernel/dot-
 Since dot-log extends `zendframework/zend-log`, the tutorial is mostly compatible with zend-log as well.
 See the [zend-log documentation](https://zendframework.github.io/zend-log/) for more detail.
 
-This article will explain the usage of the **[dot-log](https://github.com/dotkernel/dot-log)** component within Dotkernel, Zend Expressive or in a project that uses Zend Service Manager.
+## Adding the config provider
 
-Since dot-log extends zendframework/zend-log this tutorial mostly compatible with zend-log as well.
-
-For a more detailed documentation about the zend-log visit the [zend-log documentation](https://zendframework.github.io/zend-log/).
-
-## Adding The Config Provider
-
-- Enter **config/config.php**
-- If there is no entry for the config provider below, add it: \Dot\Log\ConfigProvider::class
-- Make sure it is added before with the Application-Specific components, eg.: `\Frontend\App\ConfigProvider.php`,  `\Admin\App\ConfigProvider::class`,  `MyProject\ConfigProvider::class` , etc.
-- Open the `Dot\Log\ConfigProvider`
-  - In the dependencies section you will see an **absctract factory **(`LoggerAbstractServiceFactory::class`)
-  - This class responds to "selectors" instead of class names
-  - Instead of requesting the `Zend\Log\Logger::class` from the container, `dot-log.my_logger` should be requested (or just `my_logger` if using zend-log)
-- Next, create a **log.global.php **file within **/config/autoload**
-  - return an empty array for start
+- Open `config/config.php`.
+- If there's no entry for the dot-log config provider, add `\Dot\Log\ConfigProvider::class`.
+- Make sure it's added before application-specific components, e.g. `Frontend\App\ConfigProvider::class`, `Admin\App\ConfigProvider::class`, `MyProject\ConfigProvider::class`.
+- Inside `Dot\Log\ConfigProvider`, the dependencies section registers an abstract factory, `LoggerAbstractServiceFactory::class`.
+This class responds to "selectors" instead of class names - instead of requesting `Zend\Log\Logger::class` from the container, you request `dot-log.my_logger` (or just `my_logger` if using zend-log).
+- Create a `log.global.php` file within `/config/autoload`, returning an empty array to start.
 
 ## Configuring the logger
 
-For compatibility between components and for the better understanding of this tutorial the name for the created logger will be **my_logger**.
-
-The logger name is the developer's choice and should reflect its purpose (eg.: db_error_logger - a logger that only writes the error messages in **db**).
-
-Create a key-value pair, the key should be **dot-log** (or **log** if using zend-log) and the value should be an empty array.
-
-In the newly created value add a key loggers, and the value should be an array with the key **my_logger** and an empty array as the value.
-
- 
-
-At this point your log.global.php should look like this:
+For this tutorial, the created logger is named **my_logger** (the name is the developer's choice and should reflect its purpose, e.g. `db_error_logger`).
 
-```
-return
-        ],
-    ],
-];
-```
+In `log.global.php`:
 
- 
+1. Add a top-level key `dot-log` (or `log` if using zend-log) with an array value.
+2. Inside it, add a `loggers` key.
+3. Inside that, add the logger name key (`my_logger`) with an empty array.
 
-For this logger to actually log somewhere a writer is required, otherwise the log command will be received, but the logger will have no place to write the message in.
-
-The next step will show you how to configure writing to a specific file.
+For the logger to actually log somewhere, a writer is required - without one, log calls are received but there's nowhere to write the message.
 
 ## Configuring the writer(s)
 
 Loggers must have at least one writer.
+A **writer** is an object that inherits from `Zend\Log\Writer\AbstractWriter`, responsible for recording log data to a storage backend (see the [zend-log writer documentation](https://zendframework.github.io/zend-log/writers/)).
 
-A ***writer*** is an object that inherits from `Zend\Log\Writer\AbstractWriter`. A writer's responsibility is to record log data to a storage backend. (from [zend-log's writer documentation](https://zendframework.github.io/zend-log/writers/))
-
- 
-
-### Writing to a file (stream)
-
-It is possible separate logs into multiple files using writers and filters. For example **warnings.log, errors.log**, all_messages.log.
-
-In this example all the log messages will be written in one file.
-
-- In the my_logger key insert an empty array on key **writers**
-  - The **writers** will all be used when writing logs
-- The following is the simplest example to write anything to **/data/logs/dk.log**
-
-```
-return ,
-                    ],
-                ],
-            ]
-        ],
-    ],
-];
-```
-
-The **FileWriter** key is optional, otherwise the writers array would be enumerative instead of associative.
-
-The writer **name** key is a developer-provided name for that writer, the writer name key is **mandatory**.
-
-The writer priority key is not affecting the errors that are written, it is a way to organize writers, for example:
-
-- 1 - FILE
-- 2 - SQL
-- 3 - E-mail
-
-It is the most important to write in the file, the sql or e-mail are more probably fail because the servers can be external and offline, the file is on the same server.
-
-The writer priority key is optional.
-
-To write into a file the key **stream** must be present in the **writer options** array. This is required only if writing into streams/files.
-
- 
-
-For more examples see the zend-log streams:
-
-- [Writing to Streams](https://zendframework.github.io/zend-log/writers/#writing-to-streams)
-- [Writing to Databases](https://zendframework.github.io/zend-log/writers/#writing-to-databases)
-- [Writing to FirePHP](https://zendframework.github.io/zend-log/writers/#writing-to-firephp)
-- [Writing to ChromePHP](https://zendframework.github.io/zend-log/writers/#writing-to-chromephp)
-- [Writing to Mail](https://zendframework.github.io/zend-log/writers/#writing-to-mail)
-- [Writing to MongoDB](https://zendframework.github.io/zend-log/writers/#writing-to-mongodb)
-- [Writing to Syslog](https://zendframework.github.io/zend-log/writers/#writing-to-syslog)
-- [Writing to Zend Monitor](https://zendframework.github.io/zend-log/writers/#writing-to-zend-monitor)
-
-## (Optional) Configuring the Filters
-
-A *filter* prevents a message from being written to the log. (from [zend-log filters documentation](https://zendframework.github.io/zend-log/filters/))
+It's possible to separate logs into multiple files using writers and filters (e.g. `warnings.log`, `errors.log`, `all_messages.log`).
+In the simplest example, all log messages are written to one file, e.g. `/data/logs/dk.log`, under a `writers` key inside `my_logger`.
 
-As per [PSR-3 document](https://www.php-fig.org/psr/psr-3/#5-psrlogloglevel).
+Notes on writer configuration:
 
-The log levels are: **emergency (0)**, **alert (1)**, **critical (2)**, **error (3)**, **warn (4)**, **notice (5)**, **info (6)**, **debug (7)** (in order of priority/importance)
+- The writer key name (e.g. `FileWriter`) is optional - otherwise the writers array would be enumerative instead of associative.
+- The writer's `name` key is a developer-provided name for that writer and is **mandatory**.
+- The writer's `priority` key doesn't affect which errors get written - it's only a way to organize writers (e.g. 1 - FILE, 2 - SQL, 3 - E-mail), reflecting that writing to a file is the most reliable since SQL or e-mail servers can be external and offline.
+The priority key is optional.
+- To write to a file, the `stream` key must be present in the writer's `options` array (required only when writing to streams/files).
 
-Although the plain Logger in Zend Log is not fully compatible with PSR-3, it provides a way to log all of these message types.
+More writer examples: [Streams](https://zendframework.github.io/zend-log/writers/#writing-to-streams), [Databases](https://zendframework.github.io/zend-log/writers/#writing-to-databases), [FirePHP](https://zendframework.github.io/zend-log/writers/#writing-to-firephp), [ChromePHP](https://zendframework.github.io/zend-log/writers/#writing-to-chromephp), [Mail](https://zendframework.github.io/zend-log/writers/#writing-to-mail), [MongoDB](https://zendframework.github.io/zend-log/writers/#writing-to-mongodb), [Syslog](https://zendframework.github.io/zend-log/writers/#writing-to-syslog), [Zend Monitor](https://zendframework.github.io/zend-log/writers/#writing-to-zend-monitor).
 
- 
+## (Optional) Configuring the filters
 
-Starting from the basic writer configuration, several configurations will be added for extra functionality.
+A **filter** prevents a message from being written to the log (see the [zend-log filters documentation](https://zendframework.github.io/zend-log/filters/)).
 
- 
+Per [PSR-3](https://www.php-fig.org/psr/psr-3/#5-psrlogloglevel), the log levels, in order of priority/importance, are:
 
-```
-<?php
-
-return
-                                ],
-                            ],
-                        ],
-                    ],
-                    // Only warnings
-                    'OnlyWarningsWriter' => ,
-                                ],
-                            ],
-                        ],
-                    ],
-                    // Warnings and more important messages
-                    'WarningOrHigherWriter' => ,
-                                ],
-                            ],
-                        ],
-                    ],
-                ],
-            ],
-        ],
-    ],
-];
-```
-
-As in the writer configuration, the developer can optionally use keys for associating the filters with a name.
-
-**IMPORTANT NOTE:** the operator for more important messages is **<=,** this is because the number representation is smaller for a more important message type.
-
-The filter added on the first writer is equal to not setting a filter, but it was been added to illustrate how to explicitly allow all messages.
-
-It was added opposite to the others just to demonstrate the other operator is also an option.
-
- 
-
-More examples on filters: [https://zendframework.github.io/zend-log/filters/](https://zendframework.github.io/zend-log/filters/)
+| Level | Priority number |
+|---|---|
+| emergency | 0 |
+| alert | 1 |
+| critical | 2 |
+| error | 3 |
+| warn | 4 |
+| notice | 5 |
+| info | 6 |
+| debug | 7 |
 
-## (Optional) Configuring the Formatter
+Although the plain Logger in Zend Log is not fully PSR-3 compatible, it provides a way to log all of these message types.
+The developer can optionally use keys to name filters.
+**Important:** the operator for "more important" messages is `<=`, because a smaller number represents a more important message.
 
-When using dot-log or zend-log, the logged value is not limited to a string. Arrays can be logged as well.
+More on filters: [zend-log filters documentation](https://zendframework.github.io/zend-log/filters/).
 
-For a better readability, these arrays can be serialized.
+## (Optional) Configuring the formatter
 
-Zend Log provides String formatting, XML, JSON and FirePHP formatting.
-
- 
-
-The formatter accepts following parameters:
-
-- name - the formatter class (it must implement **Zend\Log\Formatter\FormatterInterface**)
-- options - options to pass to the formatter constructor if required
-
- 
-
-The following formats the message as JSON data:
-
-```
-'formatter' => [
-    'name' => \Zend\Log\Formatter\Json::class,
-],
-```
+The logged value isn't limited to a string - arrays can be logged too, and for readability they can be serialized. Zend Log provides String, XML, JSON and FirePHP formatting.
 
- 
+The formatter config accepts:
 
-- [Simple Formatting](https://zendframework.github.io/zend-log/formatters/#simple-formatting)
-- [Formatting to JSON](https://zendframework.github.io/zend-log/formatters/#formatting-to-json)
-- [Formatting to XML](https://zendframework.github.io/zend-log/formatters/#formatting-to-xml)
-- [Formatting to FirePhp](https://zendframework.github.io/zend-log/formatters/#formatting-to-firephp)
+- `name` - the formatter class (must implement `Zend\Log\Formatter\FormatterInterface`)
+- `options` - options passed to the formatter constructor, if required
 
- 
+More on formatters: [Simple](https://zendframework.github.io/zend-log/formatters/#simple-formatting), [JSON](https://zendframework.github.io/zend-log/formatters/#formatting-to-json), [XML](https://zendframework.github.io/zend-log/formatters/#formatting-to-xml), [FirePHP](https://zendframework.github.io/zend-log/formatters/#formatting-to-firephp).
 
-## Full example
+## Full example (described)
 
-Below an example which:
+A complete configuration, as described in the article, does the following:
 
-- The log is used through **dot-log**
-- The logger name is **my_logger**
+- Uses the log through **dot-log**
+- Names the logger **my_logger**
 - Writes to file: **data/logs/dk.log**
-- Explicitly allows **all the messages** to be written
+- Explicitly allows **all messages** to be written
 - Formats the message as **JSON**
 
-The key elements are **bold**.
-
-```
-<?php
-
-return ,
-                                ],
-                            ],
-                            'formatter' => ,
-                        ],
-                    ],
-                ],
-            ],
-        ],
-    ],
-];
-```
-
- 
-
 ## Usage
 
-Basic usage of the logger is illustraded below.
-
-The messages are written to see which logs are written and which are not written.
+Basic usage of the logger:
 
-```
+```php
 use Zend\Log\Logger;
 ```
 
-...
-
-```
+```php
 $logger = $container->get('dot-log.my_logger');
 
 /** @var Logger $logger */
@@ -263,32 +121,33 @@ $logger->debug('7 debug');
 $logger->log(Logger::NOTICE, 'NOTICE from log()');
 ```
 
-## Sources:
-
-- https://zendframework.github.io/zend-log/
-- https://zendframework.github.io/zend-log/writers/
-- https://zendframework.github.io/zend-log/filters/
-
-This article will be continued in a different article that treats the error handling in middleware applications.
-
- 
-
 ## FAQ
 
 **Q: How do I register dot-log's config provider?**
-A: In config/config.php, add \Dot\Log\ConfigProvider::class if it's not already there, making sure it is added before application-specific components such as Frontend\App\ConfigProvider or Admin\App\ConfigProvider.
+A: In config/config.php, add `\Dot\Log\ConfigProvider::class` if it's not already there, making sure it is added before application-specific components such as Frontend\App\ConfigProvider or Admin\App\ConfigProvider.
 
 **Q: How is a logger retrieved from the container instead of using the plain class name?**
-A: Dot\Log\ConfigProvider registers an abstract factory, LoggerAbstractServiceFactory, that responds to "selectors" instead of class names. Instead of requesting Zend\Log\Logger::class from the container, you request dot-log.my_logger (or just my_logger if using zend-log).
+A: Dot\Log\ConfigProvider registers an abstract factory, LoggerAbstractServiceFactory, that responds to "selectors" instead of class names.
+Instead of requesting Zend\Log\Logger::class from the container, you request dot-log.my_logger (or just my_logger if using zend-log).
 
 **Q: What is a writer, and how many does a logger need?**
-A: A writer is an object that inherits from Zend\Log\Writer\AbstractWriter and is responsible for recording log data to a storage backend. Loggers must have at least one writer, and the writer's "name" key is mandatory while its "priority" key is optional and only used to organize writers, not to affect which errors get written.
+A: A writer is an object that inherits from Zend\Log\Writer\AbstractWriter and is responsible for recording log data to a storage backend.
+Loggers must have at least one writer, and the writer's "name" key is mandatory while its "priority" key is optional and only used to organize writers, not to affect which errors get written.
 
 **Q: What does a filter do, and how are log levels ordered?**
-A: A filter prevents a message from being written to the log. Per PSR-3, the log levels in order of priority/importance are emergency (0), alert (1), critical (2), error (3), warn (4), notice (5), info (6), and debug (7) - the operator for "more important" messages is <= because a smaller number represents a more important message.
+A: A filter prevents a message from being written to the log.
+Per PSR-3, the log levels in order of priority/importance are emergency (0), alert (1), critical (2), error (3), warn (4), notice (5), info (6), and debug (7) - the operator for "more important" messages is `<=` because a smaller number represents a more important message.
 
 **Q: What does the formatter configuration control?**
-A: The formatter accepts a "name" (a class implementing Zend\Log\Formatter\FormatterInterface) and "options" to pass to that formatter's constructor. Zend Log provides String, XML, JSON and FirePHP formatting, and arrays can be serialized this way for better readability.
+A: The formatter accepts a "name" (a class implementing Zend\Log\Formatter\FormatterInterface) and "options" to pass to that formatter's constructor.
+Zend Log provides String, XML, JSON and FirePHP formatting, and arrays can be serialized this way for better readability.
 
 **Q: How do you actually write log messages once the logger is configured?**
-A: Fetch the logger from the container, e.g. $logger = $container->get('dot-log.my_logger');, then call methods such as emerg(), alert(), crit(), err(), warn(), notice(), info(), debug(), or the generic log(Logger::NOTICE, 'message').
+A: Fetch the logger from the container, e.g. `$logger = $container->get('dot-log.my_logger');`, then call methods such as emerg(), alert(), crit(), err(), warn(), notice(), info(), debug(), or the generic log(Logger::NOTICE, 'message').
+
+## Resources
+
+- [zend-log documentation](https://zendframework.github.io/zend-log/)
+- [zend-log writers documentation](https://zendframework.github.io/zend-log/writers/)
+- [zend-log filters documentation](https://zendframework.github.io/zend-log/filters/)
+- [dot-log on GitHub](https://github.com/dotkernel/dot-log)
diff --git a/public/md-articles/dotkernel/manual-upgrade-of-wurfl-xml-file-in-dotkernel.md b/public/md-articles/dotkernel/manual-upgrade-of-wurfl-xml-file-in-dotkernel.md
index 5ff9d720..642745c0 100644
--- a/public/md-articles/dotkernel/manual-upgrade-of-wurfl-xml-file-in-dotkernel.md
+++ b/public/md-articles/dotkernel/manual-upgrade-of-wurfl-xml-file-in-dotkernel.md
@@ -14,32 +14,30 @@ language: "en"
 Dotkernel Application Framework bundles a WURFL XML file, but it's the last GPL version (from June 2011).
 Because of a license change to that WURFL file, Dotkernel will no longer upgrade the bundled file - it must be upgraded manually.
 
-Dotkernel Application Framework can be downloaded with WURFL XML file bundled in it, but is quite an old file,  the latest GPL version, from June 2011. Because of license changed of that WURFL file,  this bundled file will not be upgraded anymore by us.
+## Steps to manually upgrade
 
-You need to manually upgrade the xml file, if you still want to use it , and of course, please pay attention to license changes.
+1. Download the `wurfl-2.3.xml.zip` file.
+2. Rename it to `wurfl.zip`.
+3. Rename the file inside the archive to `wurfl.xml`.
+4. Replace `/externals/wurfl/wurfl.zip` with this new `wurfl.zip` file.
+5. Download the `web_browsers_patch.xml` file.
+6. Replace the `/externals/wurfl/web_browsers_patch.xml` file with this new one.
+7. Go to the Admin panel, click on the **empty** wurfl cache link, then rebuild the cache.
 
-1.  Download the wurfl-2.3.xml.zip file.
-2. Rename it to wurfl.zip
-3. Rename the file inside the archive to wurfl.xml
-4. Replace the file /externals/wurfl/wurfl.zip with this new wurfl.zip file
-5. Download the web_browsers_patch.xml file
-6. Replace the /externals/wurfl/web_browsers_patch.xml file with this new one
-7. Go to Admin panel, click on **empty** wurfl cache  link, then rebuild the cache
-
-Again, please pay attention to WURFL license changes.
-
- 
+Please pay attention to WURFL license changes when performing this upgrade.
 
 ## FAQ
 
 **Q: Why does the WURFL xml file need to be manually upgraded in Dotkernel?**
-A: Dotkernel bundles an old WURFL XML file (the latest GPL version, from June 2011). Because of a license change to that WURFL file, the bundled file will no longer be upgraded by Dotkernel, so it must be upgraded manually if you still want to use it.
+A: Dotkernel bundles an old WURFL XML file (the latest GPL version, from June 2011).
+Because of a license change to that WURFL file, the bundled file will no longer be upgraded by Dotkernel, so it must be upgraded manually if you still want to use it.
 
 **Q: What are the main steps to manually upgrade the WURFL file?**
 A: Download the wurfl-2.3.xml.zip file, rename it to wurfl.zip, rename the file inside the archive to wurfl.xml, and replace /externals/wurfl/wurfl.zip with this new wurfl.zip file.
 
 **Q: Is there anything else to replace besides wurfl.zip?**
-A: Yes. Download the web_browsers_patch.xml file and replace the /externals/wurfl/web_browsers_patch.xml file with the new one.
+A: Yes.
+Download the web_browsers_patch.xml file and replace the /externals/wurfl/web_browsers_patch.xml file with the new one.
 
 **Q: What's the last step after replacing the files?**
 A: Go to the Admin panel, click on the "empty" wurfl cache link, then rebuild the cache.
diff --git a/public/md-articles/dotkernel/migration-of-zend-framework-1-pear-channel.md b/public/md-articles/dotkernel/migration-of-zend-framework-1-pear-channel.md
index 6eea07b7..0847332d 100644
--- a/public/md-articles/dotkernel/migration-of-zend-framework-1-pear-channel.md
+++ b/public/md-articles/dotkernel/migration-of-zend-framework-1-pear-channel.md
@@ -11,49 +11,44 @@ language: "en"
 # Migration of Zend Framework 1 PEAR channel
 
 ## TL;DR
+
 The unofficial PEAR channel for Zend Framework 1 was hosted on Google Code, and once Google Code closed, it had to move.
 Because the repository is over 1 GB, it could not be migrated to GitHub, so a dedicated server was built to host the PEAR channel long-term at pear.dotkernel.com.
 
-The unofficial **PEAR channel for Zend Framework 1** was hosted on Google Code at this location: [ZF Pear](http://code.google.com/p/zend/), but since the closing of Google Code we were forced to move it.
-
-Zend Framework 1 is still used by a lot of  projects in Production, it's still a viable library collection  and it's also  running on  PHP7 ; even if is only in maintenance/security-patch mode, so it's not an option to cancel it completely.
-
-We were unable to migrate the project on github.com since the size of the repository is more then 1 GB. We resorted to building a special server that will host only the PEAR channel for Zend Framework 1 and we are commited to **keep it live and running for the long term**.
+## Why the move was needed
 
-Instructions on how to use the new channel can be found below .
+- Zend Framework 1 is still used by a lot of projects in production, is still a viable library collection, and runs on PHP7, even though it is only in maintenance/security-patch mode, so cancelling it completely was not an option.
+- The team was unable to migrate the project to github.com because the repository is more than 1 GB in size.
+- A special server was built to host only the PEAR channel for Zend Framework 1, with a commitment to keep it live and running for the long term.
 
 ## PEAR Channel Migration Guide
 
-Use the PEAR installer:
+Use the PEAR installer to switch to the new channel:
 
-1. Remove the installed pear package
+1. Remove the installed pear package:
 
-```
+```shell
 pear uninstall zend/zend
 ```
 
-2. Remove the old googlecode channel
+2. Remove the old Google Code channel:
 
-```
+```shell
 pear channel-delete zend.googlecode.com/svn
 ```
 
-3. Discover the new channel
+3. Discover the new channel:
 
-```
+```shell
 pear channel-discover pear.dotkernel.com/zf1/svn
 ```
 
-4. Install the package
+4. Install the package:
 
-```
+```shell
 pear install zend/zend
 ```
 
-Follow [@dotkernel ](https://twitter.com/dotkernel) in order to be up to date related to new releases.
-
- 
-
 ## FAQ
 
 **Q: Why did the PEAR channel for Zend Framework 1 need to move?**
@@ -66,4 +61,8 @@ A: The team was unable to migrate the project to github.com because the reposito
 A: Zend Framework 1 is still used by a lot of projects in production, is still a viable library collection, and runs on PHP7, even though it is only in maintenance/security-patch mode.
 
 **Q: How do I switch to the new PEAR channel?**
-A: Using the PEAR installer: remove the installed package with pear uninstall zend/zend, remove the old Google Code channel with pear channel-delete zend.googlecode.com/svn, discover the new channel with pear channel-discover pear.dotkernel.com/zf1/svn, and then reinstall the package with pear install zend/zend.
+A: Using the PEAR installer: remove the installed package with `pear uninstall zend/zend`, remove the old Google Code channel with `pear channel-delete zend.googlecode.com/svn`, discover the new channel with `pear channel-discover pear.dotkernel.com/zf1/svn`, and then reinstall the package with `pear install zend/zend`.
+
+## Resources
+
+- [@dotkernel on Twitter](https://twitter.com/dotkernel)
diff --git a/public/md-articles/dotkernel/new-features-in-zend-framework-1-12.md b/public/md-articles/dotkernel/new-features-in-zend-framework-1-12.md
index d5e719ec..d68b3ed4 100644
--- a/public/md-articles/dotkernel/new-features-in-zend-framework-1-12.md
+++ b/public/md-articles/dotkernel/new-features-in-zend-framework-1-12.md
@@ -11,58 +11,28 @@ language: "en"
 # New Features in Zend Framework 1.12
 
 ## TL;DR
+
 Per Matthew Weier O'Phinney's announcement, the Zend Framework team made available the first release candidate of the Zend Framework 1.12 series, 1.12.0RC1.
 It back ports several ZF2 components to ZF1, removes the WurflApi adapter due to licensing changes, and fixes over 200 reported issues.
 
-According to [Matthew Weier O'Phinney announcement](http://devzone.zend.com/2366/zend-framework-1-12-series-1-12-0rc1-now-available/), Zend Framework team is pleased to announce the immediate availability of the first release candidate of the Zend Framework 1.12 series, 1.12.0RC1
-
-##  New Features
-
-- Zend_Loader changes
-
-> A number of autoloaders and autoloader facilities were back ported from ZF2 to provide performant alternatives to those already available in the 1.X releases.  These include: Zend_Loader_StandardAutoloader, which improves on Zend_Loader_Autoloader by allowing the ability to specify a specific path to associate with a vendor prefix or namespace; Zend_Loader_ClassMapAutoloader, which provides the ability to use lookup tables for autoloading (which are typically the fastest possible way to autoload); and Zend_Loader_AutoloaderFactory, which can both create and update autoloaders for you, as well as register them with spl_autoload_register().
-> 
-> The Zend_Loader changes were back ported from ZF2 by Matthew Weier O'Phinney
-
-- Zend_EventManager
-
-> Zend_EventManager is a component that allows you to attach and detach listeners to named events, both on a per-instance basis as well as via shared collections; trigger events; and interrupt execution of listeners.
-> 
-> Zend_EventManager was back ported from ZF2 by Matthew Weier O'Phinney
-
-- Zend_Http_UserAgent_Features_Adapter_Browscap
-
-> This class provides a features adapter that calls get_browser() in order to discover mobile device capabilities to inject into UserAgent device instances.
-> 
-> Browscap ([http://browsers.garykeith.com/](http://browsers.garykeith.com/)) is an open project dedicated to collecting an disseminating a "database" of browser capabilities. PHP has built-in support for using these files via the get_browser() function. This function requires that your php.ini provides a browscap entry pointing to the PHP-specific php_browscap.ini file which is available at [http://browsers.garykeith.com/stream.asp?PHP_BrowsCapINI](http://browsers.garykeith.com/stream.asp?PHP_BrowsCapINI).
-> 
-> Zend_Http_UserAgent_Features_Adapter_Browscap was created by Matthew Weier O'Phinney
+## New Features
 
-- Zend_Mobile_Push
-
-> Zend_Mobile_Push is a component for implementing push notifications for the 3 major push notification platforms (Apple (Apns), Google (C2dm) and Microsoft (Mpns).
-> 
-> Zend_Mobile_Push was contributed by Mike Willbanks.
-
-- Zend_Gdata_Analytics
-
-> Zend_Gdata_Analytics is an extension to Zend_Gdata to allow interaction with Google's Analytics Data Export API. This extension does not encompass any major changes in the overall operation of Zend_Gdata components.
-> 
-> Zend_Gdata_Analytics was contributed by Daniel Hartmann.
+| Feature | Description |
+|---|---|
+| Zend_Loader changes | A number of autoloaders and autoloader facilities were back ported from ZF2, including `Zend_Loader_StandardAutoloader` (improves on `Zend_Loader_Autoloader` by allowing a specific path to be associated with a vendor prefix or namespace), `Zend_Loader_ClassMapAutoloader` (lookup-table based autoloading, typically the fastest method), and `Zend_Loader_AutoloaderFactory` (can create and update autoloaders and register them with `spl_autoload_register()`). Back ported by Matthew Weier O'Phinney. |
+| Zend_EventManager | A component that lets you attach and detach listeners to named events, per-instance or via shared collections, trigger events, and interrupt execution of listeners. Back ported by Matthew Weier O'Phinney. |
+| Zend_Http_UserAgent_Features_Adapter_Browscap | A features adapter that calls `get_browser()` to discover mobile device capabilities for injection into UserAgent device instances, relying on the Browscap project's `php_browscap.ini` file. Created by Matthew Weier O'Phinney. |
+| Zend_Mobile_Push | A component for implementing push notifications across the three major platforms: Apple (APNs), Google (C2DM), and Microsoft (MPNS). Contributed by Mike Willbanks. |
+| Zend_Gdata_Analytics | An extension to Zend_Gdata for interacting with Google's Analytics Data Export API; does not change the overall operation of Zend_Gdata components. Contributed by Daniel Hartmann. |
 
 ## Removed features
 
-- Zend_Http_UserAgent_Features_Adapter_WurflApi  ( announced few months ago [here](http://www.dotkernel.com/dotkernel/zend-framework-dropped-integration-of-wurfl-adapter/))
-
-> Due to the changes in licensing of WURFL, we have removed the WurflApi adapter. We will be providing the WurflApi adapter to ScientiaMobile so that users of WURFL will still have that option.
+- `Zend_Http_UserAgent_Features_Adapter_WurflApi` was removed due to changes in WURFL's licensing (announced previously).
+The team planned to provide the WurflApi adapter directly to ScientiaMobile so WURFL users would still have that option.
 
 ## Bug Fixes
 
-> In addition over 200 reported issues in the tracker have been fixed. We'd like to particularly thank Adam Lundrigan, Frank Brückner and Martin Hujer for their efforts in making this happen. Thanks also to the many people who ran the ZF1 unit tests and reported their results!
-> 
-> For a complete list go here:[http://framework.zend.com/issues/secure/IssueNavigator.jspa?requestId=12877](http://framework.zend.com/issues/secure/IssueNavigator.jspa?requestId=12877)
-
- 
+Over 200 reported issues in the tracker were fixed, with particular thanks to Adam Lundrigan, Frank Brückner and Martin Hujer, as well as everyone who ran the ZF1 unit tests and reported results.
 
 ## FAQ
 
@@ -76,7 +46,16 @@ A: A number of autoloaders and autoloader facilities were back ported from ZF2,
 A: Zend_EventManager is a component, also back ported from ZF2, that lets you attach and detach listeners to named events (per-instance or via shared collections), trigger events, and interrupt execution of listeners.
 
 **Q: Why was the WurflApi adapter removed?**
-A: Zend_Http_UserAgent_Features_Adapter_WurflApi was removed due to changes in the licensing of WURFL. The team planned to provide the WurflApi adapter to ScientiaMobile so WURFL users would still have that option.
+A: Zend_Http_UserAgent_Features_Adapter_WurflApi was removed due to changes in the licensing of WURFL.
+The team planned to provide the WurflApi adapter to ScientiaMobile so WURFL users would still have that option.
 
 **Q: How many bugs were fixed in this release?**
 A: Over 200 reported issues in the tracker were fixed, with particular thanks credited to Adam Lundrigan, Frank Brückner and Martin Hujer, as well as everyone who ran the ZF1 unit tests and reported results.
+
+## Resources
+
+- [Matthew Weier O'Phinney's announcement](http://devzone.zend.com/2366/zend-framework-1-12-series-1-12-0rc1-now-available/)
+- [Browscap project](http://browsers.garykeith.com/)
+- [php_browscap.ini download](http://browsers.garykeith.com/stream.asp?PHP_BrowsCapINI)
+- [Prior WurflApi removal announcement](http://www.dotkernel.com/dotkernel/zend-framework-dropped-integration-of-wurfl-adapter/)
+- [Complete issue tracker list](http://framework.zend.com/issues/secure/IssueNavigator.jspa?requestId=12877)
diff --git a/public/md-articles/dotkernel/php-formatter-and-templates-for-zend-studio-10-1.md b/public/md-articles/dotkernel/php-formatter-and-templates-for-zend-studio-10-1.md
index 72558d2e..b8ab7eed 100644
--- a/public/md-articles/dotkernel/php-formatter-and-templates-for-zend-studio-10-1.md
+++ b/public/md-articles/dotkernel/php-formatter-and-templates-for-zend-studio-10-1.md
@@ -10,19 +10,10 @@ language: "en"
 
 # PHP Formatter and Templates for Zend Studio 10.1
 
-Because Zend donated the Zend Studio's Formatter upstream to the PDT project, the Formatter plugin for Zend Studio 10.1 need to be changed: replace  "com.zend.php" to "org.eclipse.php".
+Because Zend donated the Zend Studio Formatter upstream to the PDT project, the Formatter plugin for Zend Studio 10.1 needs to be changed: replace "com.zend.php" with "org.eclipse.php".
+The updated file is available as the Dotkernel PHP Formatter for Zend Studio 10.1.
 
-See  the updated file  [Dotkernel PHP Formatter for Zend Studio 10.1](http://www.dotkernel.com/download/?did=37)
-
-About PHP Formatter , see [http://files.zend.com/help/Zend-Studio-10/zend-studio.htm#formatter.htm](http://files.zend.com/help/Zend-Studio-10/zend-studio.htm#formatter.htm)
-
- 
-
-Also, we created the templates file for Zend Studio 10.1 , according to Dotkernel coding standard, see the file: [Templates for Zend Studio](http://www.dotkernel.com/download/?did=38)
-
-About Templates in Zend Studio and how to import/export: [http://files.zend.com/help/Zend-Studio-10/zend-studio.htm#templates.htm](http://files.zend.com/help/Zend-Studio-10/zend-studio.htm#templates.htm)
-
- 
+Dotkernel also created a templates file for Zend Studio 10.1, built according to the Dotkernel coding standard.
 
 ## FAQ
 
@@ -31,3 +22,10 @@ A: Because Zend donated the Zend Studio Formatter upstream to the PDT project, t
 
 **Q: Where can I get Dotkernel's updated Formatter and Templates files for Zend Studio 10.1?**
 A: The updated PHP Formatter file for Zend Studio 10.1 and a templates file built according to the Dotkernel coding standard are both available as downloads linked in the article.
+
+## Resources
+
+- [Dotkernel PHP Formatter for Zend Studio 10.1](http://www.dotkernel.com/download/?did=37)
+- [About PHP Formatter (Zend Studio docs)](http://files.zend.com/help/Zend-Studio-10/zend-studio.htm#formatter.htm)
+- [Templates for Zend Studio](http://www.dotkernel.com/download/?did=38)
+- [About Templates in Zend Studio and how to import/export (Zend Studio docs)](http://files.zend.com/help/Zend-Studio-10/zend-studio.htm#templates.htm)
diff --git a/public/md-articles/dotkernel/protecting-admin-folder-with-htaccess-in-plesk.md b/public/md-articles/dotkernel/protecting-admin-folder-with-htaccess-in-plesk.md
index fd44c8a2..7bb5ef23 100644
--- a/public/md-articles/dotkernel/protecting-admin-folder-with-htaccess-in-plesk.md
+++ b/public/md-articles/dotkernel/protecting-admin-folder-with-htaccess-in-plesk.md
@@ -10,28 +10,26 @@ language: "en"
 
 # Protecting admin folder with .htaccess in Plesk
 
-In **/var/www/vhosts/exampledomain.com/conf/vhost.conf** file add this code:
+## Steps
 
-```
-< Location /admin>
+1. In `/var/www/vhosts/exampledomain.com/conf/vhost.conf`, add a Location block for /admin:
+
+```shell
+<Location /admin>
    AuthType Basic
    AuthName "My Site Admin"
    AuthUserFile /var/www/vhosts/exampledomain.com/conf/.htpasswd
-  Require valid-user
-< /Location >
+   Require valid-user
+</Location>
 ```
 
- 
-
-Notice the server that vhost.conf has been added/changed with command:
+2. Notify the server that vhost.conf has been added/changed:
 
-```
+```shell
 /usr/local/psa/admin/sbin/websrvmng -a
 ```
 
- 
-
-Then create the .htpasswd file and upload it to **/var/www/vhosts/exampledomain.com/conf/**
+3. Create the `.htpasswd` file and upload it to `/var/www/vhosts/exampledomain.com/conf/`.
 
 ## FAQ
 
@@ -39,4 +37,4 @@ Then create the .htpasswd file and upload it to **/var/www/vhosts/exampledomain.
 A: Add a Location block for /admin to the vhost.conf file (e.g. /var/www/vhosts/exampledomain.com/conf/vhost.conf) using AuthType Basic, an AuthName, an AuthUserFile pointing to a .htpasswd file, and Require valid-user.
 
 **Q: After editing vhost.conf, how do I apply the change and finish setup in Plesk?**
-A: Notify the server that vhost.conf has changed by running /usr/local/psa/admin/sbin/websrvmng -a, then create the .htpasswd file and upload it to the same conf directory referenced in the AuthUserFile directive.
+A: Notify the server that vhost.conf has changed by running `/usr/local/psa/admin/sbin/websrvmng -a`, then create the .htpasswd file and upload it to the same conf directory referenced in the AuthUserFile directive.
diff --git a/public/md-articles/dotkernel/replacing-laminas-mail-with-symfony-mailer-in-dot-mail.md b/public/md-articles/dotkernel/replacing-laminas-mail-with-symfony-mailer-in-dot-mail.md
index 5b8d5181..5bbca5ed 100644
--- a/public/md-articles/dotkernel/replacing-laminas-mail-with-symfony-mailer-in-dot-mail.md
+++ b/public/md-articles/dotkernel/replacing-laminas-mail-with-symfony-mailer-in-dot-mail.md
@@ -11,95 +11,61 @@ language: "en"
 # Replacing laminas-mail with Symfony mailer in dot-mail
 
 ## TL;DR
+
 The Laminas Technical Steering Committee decided on 2023-12-04 to abandon laminas/laminas-mail.
 Dotkernel responded by replacing it with symfony/mailer inside the dotkernel/dot-mail package (version 5), aiming for minimal impact on existing projects - calls to send mail stay the same, though mime and imap related functionality is removed.
 
 ## What prompted the change
 
-According to the discussion from the [LaminasTechnical steering Committee of 2023-12-04](https://github.com/laminas/technical-steering-committee/blob/main/meetings/minutes/2023-12-04-TSC-Minutes.md#maintainers-for-laminas-mime-and-laminas-mail), it was decided that the [laminas/laminas-mail](https://github.com/laminas/laminas-mail) package would be abandoned. On the one hand, there is nobody to maintain the package and on the other, there are several alternatives available in the ecosystem:
+According to the Laminas Technical Steering Committee minutes of 2023-12-04, laminas/laminas-mail was going to be abandoned: nobody was available to maintain it, and alternatives already existed in the ecosystem:
 
-- [ddeboer/imap](https://github.com/ddeboer/imap) for interacting with IMAP
-- [zbateson/mail-mime-parser](https://github.com/zbateson/mail-mime-parser) for parsing MIME messages
-- [symfony/mailer](https://github.com/symfony/mailer) for sending mail
+| Purpose | Package |
+|---|---|
+| Interacting with IMAP | [ddeboer/imap](https://github.com/ddeboer/imap) |
+| Parsing MIME messages | [zbateson/mail-mime-parser](https://github.com/zbateson/mail-mime-parser) |
+| Sending mail | [symfony/mailer](https://github.com/symfony/mailer) |
 
 ## How Dotkernel handles the issue
 
-The Dotkernel team has also opted to replace the laminas/laminas-mail package in the [dotkernel/dot-mail](https://github.com/dotkernel/dot-mail) package. This meant revising the code, including the configuraton files. The optimal way to handle this was to try to have minimal impact on existing projects that already use dotkernel/dot-mail. This means that the calls to send the mail should remain the same, even if some lesser-used functionality like mime and imap are lost.
+The Dotkernel team opted to replace laminas/laminas-mail in the [dotkernel/dot-mail](https://github.com/dotkernel/dot-mail) package.
+This meant revising the code, including configuration files, while trying to have minimal impact on existing projects: the calls to send mail remain the same, even though some lesser-used functionality like mime and imap is lost.
 
 ## Technical approach
 
-In this article we will list the edits that enabled the switch from laminas/laminas-mail to symfony/mailer in the dotkernel/dot-mail package. You can follow all the changes in this list of PRs:
+The switch from laminas/laminas-mail to symfony/mailer in dotkernel/dot-mail is covered across these pull requests:
 
 - [dot-mail PR 65](https://github.com/dotkernel/dot-mail/pull/65/files)
 - [dot-mail PR 66](https://github.com/dotkernel/dot-mail/pull/66/files)
 - [dot-mail PR 67](https://github.com/dotkernel/dot-mail/pull/67/files)
 - [dot-mail PR 69](https://github.com/dotkernel/dot-mail/pull/69/files)
 
-> Function definition changes will not be covered in this article.
-
-The configuration file `mail.global.php` was revised to remove features that are no longer available and to make it easier to configure.
+> Function definition changes are not covered in the article.
 
-```
-<?php
-
-declare(strict_types=1);
-
-return ,
-                //copy destination addresses
-                'cc' => [],
-                //hidden copy destination addresses
-                'bcc' => [],
-                //email subject
-                'subject' => '',
-                //body options - content can be plain text, HTML
-                'body' => ,
-                //attachments config
-                'attachments' => ,
-                    'dir'   => ,
-                ],
-            ],
-            /**
-             * the mail transport to use can be any class implementing
-             * Symfony\Component\Mailer\Transport\TransportInterface
-             *
-             * for standard mail transports, you can use these aliases:
-             * - sendmail  => Symfony\Component\Mailer\Transport\SendmailTransport
-             * - esmtp     => Symfony\Component\Mailer\Transport\Smtp\EsmtpTransport
-             *
-             * defaults to sendmail
-             **/
-            'transport' => 'sendmail',
-            //options that will be used only if esmtp adapter is used
-            'smtp_options' => ,
-            ],
-        ],
-        // option to log the SENT emails
-        'log' => ,
-    ],
-];
-```
+The `mail.global.php` configuration file was revised to remove features that are no longer available and to make it easier to configure.
+The mail transport can be any class implementing `Symfony\Component\Mailer\Transport\TransportInterface`; standard aliases are `sendmail` (`Symfony\Component\Mailer\Transport\SendmailTransport`) and `esmtp` (`Symfony\Component\Mailer\Transport\Smtp\EsmtpTransport`), defaulting to `sendmail`.
+`smtp_options` are used only when the esmtp adapter is used, and there is a `log` option to log sent emails.
 
-Make sure to use **ONE** of the below transporters, based on your server configuration.
+Use ONE of the below transporters, based on your server configuration:
 
-```
+```php
 'transport' => 'sendmail',
 ```
 
-**OR**
+OR
 
-```
+```php
 'transport' => 'esmtp',
 ```
 
-We set **Sendmail** to be the default mail transport.
+Sendmail is set as the default mail transport.
 
-## How to update `dotkernel/dot-mail` from version 3 or version 4 to version 5 in your projects
+## How to update dotkernel/dot-mail from version 3 or 4 to version 5
 
-- The first thing to do is download the new [mail configuration file](https://github.com/dotkernel/dot-mail/blob/5.0/config/mail.global.php.dist).
-- Add the values you configured for your project, focusing on `transport`, `message_options` and `smtp_options`, then replace your old configuration file.
-- In your `composer.json` update `"dotkernel/dot-mail": "^5.0.0",` and run `composer update` in the command line.
+1. Download the new [mail configuration file](https://github.com/dotkernel/dot-mail/blob/5.0/config/mail.global.php.dist).
+2. Add the values you configured for your project, focusing on `transport`, `message_options` and `smtp_options`, then replace your old configuration file.
+3. In your `composer.json`, update to `"dotkernel/dot-mail": "^5.0.0"` and run `composer update`.
 
-At this moment, `mime` and `imap` related functionality is removed.
+At this point, `mime` and `imap` related functionality is removed.
 
 ## FAQ
 
@@ -113,10 +79,25 @@ A: The alternatives mentioned are ddeboer/imap for interacting with IMAP, zbates
 A: The Dotkernel team replaced laminas/laminas-mail with symfony/mailer inside the dotkernel/dot-mail package, revising the code and configuration files while aiming for minimal impact on existing projects, so the calls used to send mail stay the same, even though some lesser-used functionality like mime and imap is lost.
 
 **Q: Which mail transport does dot-mail use by default?**
-A: The revised mail.global.php configuration defaults the transport to sendmail. You should use ONE of the transporters, either 'transport' => 'sendmail' or 'transport' => 'esmtp', based on your server configuration; Sendmail was set as the default.
+A: The revised mail.global.php configuration defaults the transport to sendmail.
+You should use ONE of the transporters, either 'transport' => 'sendmail' or 'transport' => 'esmtp', based on your server configuration; Sendmail was set as the default.
 
 **Q: How do I update dotkernel/dot-mail from version 3 or 4 to version 5?**
 A: Download the new mail.global.php.dist configuration file, add the values you configured for your project (focusing on transport, message_options and smtp_options) to replace your old configuration file, then update "dotkernel/dot-mail" to "^5.0.0" in composer.json and run composer update.
 
 **Q: What functionality is lost after switching to symfony/mailer?**
 A: At the time of the article, mime and imap related functionality is removed from dot-mail as a result of the switch.
+
+## Resources
+
+- [Laminas Technical Steering Committee minutes, 2023-12-04](https://github.com/laminas/technical-steering-committee/blob/main/meetings/minutes/2023-12-04-TSC-Minutes.md#maintainers-for-laminas-mime-and-laminas-mail)
+- [laminas/laminas-mail](https://github.com/laminas/laminas-mail)
+- [ddeboer/imap](https://github.com/ddeboer/imap)
+- [zbateson/mail-mime-parser](https://github.com/zbateson/mail-mime-parser)
+- [symfony/mailer](https://github.com/symfony/mailer)
+- [dotkernel/dot-mail](https://github.com/dotkernel/dot-mail)
+- [dot-mail PR 65](https://github.com/dotkernel/dot-mail/pull/65/files)
+- [dot-mail PR 66](https://github.com/dotkernel/dot-mail/pull/66/files)
+- [dot-mail PR 67](https://github.com/dotkernel/dot-mail/pull/67/files)
+- [dot-mail PR 69](https://github.com/dotkernel/dot-mail/pull/69/files)
+- [New mail.global.php.dist configuration file](https://github.com/dotkernel/dot-mail/blob/5.0/config/mail.global.php.dist)
diff --git a/public/md-articles/dotkernel/scientia-mobile-licensed-its-wurfl-cloud-php-library-to-dotkernel-1-6.md b/public/md-articles/dotkernel/scientia-mobile-licensed-its-wurfl-cloud-php-library-to-dotkernel-1-6.md
index 9581333e..1f703ac7 100644
--- a/public/md-articles/dotkernel/scientia-mobile-licensed-its-wurfl-cloud-php-library-to-dotkernel-1-6.md
+++ b/public/md-articles/dotkernel/scientia-mobile-licensed-its-wurfl-cloud-php-library-to-dotkernel-1-6.md
@@ -11,23 +11,21 @@ language: "en"
 # Scientia Mobile licensed its Wurfl Cloud PHP library to Dotkernel 1.6
 
 ## TL;DR
-In Dotkernel 1.6.0, released on May 16th, 2012, the GPL'ed WURFL PHP library was removed because its code was obsolete and the XML file structure had changed. It was replaced by Scientia Mobile's WURFL Cloud PHP library, made available to Dotkernel under a special, restrictive license.
-
-In the Dotkernel version 1.6.0 , released on May 16th, 2012 we have removed the GPL'ed WURFL PHP library , as the code it was obsolete anyway and also the structure of the XML file was changed.
-
-Instead , we implemented the [Scientia Mobile's](http://www.scientiamobile.com/)WURFL Cloud PHP  library .
 
-Instructions about how to signup for a free account , and how to setup your API key can be found [here .](http://www.dotkernel.com/dotkernel/detecting-mobile-devices-in-dotkernel-1-6/)
+In Dotkernel 1.6.0, released on May 16th, 2012, the GPL'ed WURFL PHP library was removed because its code was obsolete and the XML file structure had changed. It was replaced by Scientia Mobile's WURFL Cloud PHP library, made available to Dotkernel under a special, restrictive license.
 
-In the near future, we will create a template in Wurfl Cloud API control panel,  at Scientia Mobile,  ready to be used in Dotkernel implementations.
+## What changed
 
-Also, we got a special license, please read the file:
+- The GPL'ed WURFL PHP library was removed in Dotkernel 1.6.0 (released May 16th, 2012) because the code was obsolete and the structure of the XML file had changed.
+- Scientia Mobile's WURFL Cloud PHP library was implemented instead.
+- A future plan mentioned in the article was to create a template in the Wurfl Cloud API control panel at Scientia Mobile, ready to be used in Dotkernel implementations.
+- Instructions on signing up for a free account and setting up an API key are covered in a separate article, "Detecting Mobile Devices in Dotkernel 1.6".
 
-[dotkernel/library/WurflCloud/LICENSE.txt](http://websvn.dotkernel.net/filedetails.php?repname=Dotkernel&path=%2Ftrunk%2Flibrary%2FWurflCloud%2FLICENSE.txt) and notice Dotkernel mention
+## License terms
 
-> License is non-transferable, conditioned, limited to the version received and to the use and distribution of this software only in connection with the **Dotkernel** software framework, and does not allow making derivative works even when the source code is provided or the language is an interpreted one and regardless of whether the code is not obfuscated.
+Dotkernel received a special license for the WURFL Cloud PHP library, documented in `dotkernel/library/WurflCloud/LICENSE.txt`:
 
- 
+> License is non-transferable, conditioned, limited to the version received and to the use and distribution of this software only in connection with the Dotkernel software framework, and does not allow making derivative works even when the source code is provided or the language is an interpreted one and regardless of whether the code is not obfuscated.
 
 ## FAQ
 
@@ -41,4 +39,11 @@ A: Dotkernel implemented Scientia Mobile's WURFL Cloud PHP library instead.
 A: Instructions on how to sign up for a free account and set up your API key are linked in the article, pointing to the "Detecting Mobile Devices in Dotkernel 1.6" article.
 
 **Q: What are the terms of Dotkernel's special WURFL Cloud license?**
-A: The license is non-transferable, conditioned, limited to the version received, and restricted to use and distribution only in connection with the Dotkernel software framework. It does not allow making derivative works, even when source code is provided or the code is not obfuscated.
+A: The license is non-transferable, conditioned, limited to the version received, and restricted to use and distribution only in connection with the Dotkernel software framework.
+It does not allow making derivative works, even when source code is provided or the code is not obfuscated.
+
+## Resources
+
+- [Scientia Mobile](http://www.scientiamobile.com/)
+- [Detecting Mobile Devices in Dotkernel 1.6](http://www.dotkernel.com/dotkernel/detecting-mobile-devices-in-dotkernel-1-6/)
+- [dotkernel/library/WurflCloud/LICENSE.txt](http://websvn.dotkernel.net/filedetails.php?repname=Dotkernel&path=%2Ftrunk%2Flibrary%2FWurflCloud%2FLICENSE.txt)
diff --git a/public/md-articles/dotkernel/sending-emails-using-dot-email-component-and-zend-email.md b/public/md-articles/dotkernel/sending-emails-using-dot-email-component-and-zend-email.md
index 8c5c073c..d2d286c2 100644
--- a/public/md-articles/dotkernel/sending-emails-using-dot-email-component-and-zend-email.md
+++ b/public/md-articles/dotkernel/sending-emails-using-dot-email-component-and-zend-email.md
@@ -11,21 +11,25 @@ language: "en"
 # Sending emails using Dot_Email component and Zend_Email
 
 ## TL;DR
+
 Dot_Email extends Zend_Mail, so all of Zend_Mail's methods are available in it.
 Beyond its constructor, Dot_Email itself adds only two methods: setContent() and send().
 To send an email you must always call addTo(), setSubject(), one of setBodyText()/setBodyHtml()/setContent(), and finally send().
 
-**Dot_Email** class extends Zend_Mail, so all the methods from Zend_Mail are available  in Dot_Email.
+## Dot_Email overview
 
-**Dot_Email** is a simple class composed only from 2 methods, except constructor, all  other methods beeing inherited  from Zend_Mail. 1.   **setContent()** , as the name is suggesting, set the body of the email by calling setBodyText() (if format is "text/plain") or setBodyHtml() (if format is "text/html").
+Dot_Email is a simple class composed of only two methods (besides the constructor); every other method is inherited from Zend_Mail.
 
-Note the declaration of this method: setContent ($content, $format = 'text/plain')
+| Method | Description |
+|---|---|
+| `setContent($content, $format = 'text/plain')` | Sets the body of the email by calling `setBodyText()` if format is "text/plain", or `setBodyHtml()` if format is "text/html". |
+| `send()` | Sets the transporter and calls the parent's `send()` method to send the email. |
 
-2.  **send()**, set the transporter and is calling parent::send() method for sending the email
+## Sending an email
 
-For sending the email you MUST use this methods in the code above:
+For sending the email you MUST use these methods:
 
-```
+```php
 $dotEmail = new Dot_Email();
 $dotEmail->addTo($email);
 $dotEmail->setSubject('Forgot Password');
@@ -41,32 +45,33 @@ else
 }
 ```
 
-Only if you want to overwrite the default Email and Name, add the below lines:
+Only if you want to overwrite the default Email and Name, add:
 
-```
+```php
 $dotEmail->setFrom($fromEmail, $fromName);
 $dotEmail->setReplyTo($fromEmail, $fromName);
 ```
 
-**NOTE*:** you always have to use  **addTo()**,  **setSubject()**, **setBodyText()** or **setBodyHtml()** or **setContent()**, and finally send() method.
+**NOTE:** you always have to use addTo(), setSubject(), setBodyText() or setBodyHtml() or setContent(), and finally the send() method.
 
-Methods inherited  from Zend_Mail and that can be used in your code are:
+## Methods inherited from Zend_Mail
 
-1. setBodyText($txt,$charset=null,$encoding=Zend_Mime::ENCODING_QUOTEDPRINTABLE)
-2. setBodyHtml($html,$charset=null,$encoding=Zend_Mime::ENCODING_QUOTEDPRINTABLE)
-3. addTo($email, $name='')
-4. addCc($email, $name='')
-5. addBcc($email)
-6. setFrom($email, $name = null)
-7. setReplyTo($email, $name = null)
-8. setReturnPath($email)
-9. setSubject($subject)
-10. addHeader($name, $value, $append = false)
+1. `setBodyText($txt, $charset=null, $encoding=Zend_Mime::ENCODING_QUOTEDPRINTABLE)`
+2. `setBodyHtml($html, $charset=null, $encoding=Zend_Mime::ENCODING_QUOTEDPRINTABLE)`
+3. `addTo($email, $name='')`
+4. `addCc($email, $name='')`
+5. `addBcc($email)`
+6. `setFrom($email, $name = null)`
+7. `setReplyTo($email, $name = null)`
+8. `setReturnPath($email)`
+9. `setSubject($subject)`
+10. `addHeader($name, $value, $append = false)`
 
 ## FAQ
 
 **Q: What is Dot_Email?**
-A: Dot_Email is a class that extends Zend_Mail, so all methods from Zend_Mail are available in it. Aside from its constructor, Dot_Email itself is composed of only two methods, with everything else inherited from Zend_Mail.
+A: Dot_Email is a class that extends Zend_Mail, so all methods from Zend_Mail are available in it.
+Aside from its constructor, Dot_Email itself is composed of only two methods, with everything else inherited from Zend_Mail.
 
 **Q: What are the two methods that Dot_Email adds on top of Zend_Mail?**
 A: setContent($content, $format = 'text/plain') sets the body of the email by calling setBodyText() when the format is "text/plain" or setBodyHtml() when the format is "text/html". send() sets the transporter and calls the parent::send() method to send the email.
diff --git a/public/md-articles/dotkernel/templating-in-dotkernel3.md b/public/md-articles/dotkernel/templating-in-dotkernel3.md
index 5cc3c81c..a50b0156 100644
--- a/public/md-articles/dotkernel/templating-in-dotkernel3.md
+++ b/public/md-articles/dotkernel/templating-in-dotkernel3.md
@@ -11,18 +11,25 @@ language: "en"
 # Templating in Dotkernel3
 
 ## TL;DR
+
 Dotkernel3 moved from its previous, 10-year-old templating engine to the popular Twig Templating Engine, gaining layouts, loops, variables, and escaping, while giving developers the familiarity of HTML with the overview and convenience of PHP.
 
-**Dotkernel3** aims to improve the Dotkernel stack in every way possible, and one of the painpoints in the previous version of Dotkernel was the templating engine. Albeit a solid and robust templating engine, it was also 10 years old, and used techniques that's slightly outdated by now.
+## Why the switch was made
+
+One of the pain points in the previous version of Dotkernel was the templating engine.
+Although it was solid and robust, it was also 10 years old and used techniques that had become slightly outdated.
+
+## What Twig brings to Dotkernel3
 
-In Dotkernel 3, we made the move to the popular [**Twig Templating Engine**](https://twig.symfony.com/), which will allow us to take our templates to a whole new level. It can now be written as HTML code, with some extra Twig tags; It is incredibly powerful and includes features such as:
+Templates can now be written as HTML code with extra Twig tags.
+Twig is powerful and includes features such as:
 
 - Layouts
 - Loops
 - Variables
 - Escaping
 
-The templating engine in **Dotkernel3** gives you the familiarity of HTML with the overview and convenience of PHP.
+The templating engine in Dotkernel3 gives the familiarity of HTML with the overview and convenience of PHP.
 
 ## FAQ
 
@@ -36,4 +43,8 @@ A: The previous templating engine, although solid and robust, was also 10 years
 A: Templates can now be written as HTML code with extra Twig tags, and Twig includes features such as layouts, loops, variables, and escaping, giving the familiarity of HTML with the overview and convenience of PHP.
 
 **Q: Where can I read the official Twig templating documentation for Dotkernel?**
-A: The official documentation is available at twig.symfony.com.
+A: The official documentation is available at [twig.symfony.com](https://twig.symfony.com/).
+
+## Resources
+
+- [Twig Templating Engine](https://twig.symfony.com/)
diff --git a/public/md-articles/dotkernel/test-article.md b/public/md-articles/dotkernel/test-article.md
index b7653abf..722fa093 100644
--- a/public/md-articles/dotkernel/test-article.md
+++ b/public/md-articles/dotkernel/test-article.md
@@ -11,8 +11,11 @@ language: "en"
 # Test article
 
 ## TL;DR
+
 This is a test article added to the dotkernel category for testing purposes. This article is now updated.
 
+## Overview
+
 ![](/uploads/article/019fd6ae-4ce6-71cc-99aa-33741b77758c/test-article.png)
 
 This is a test article used for fixture and testing purposes. This article is now updated.
diff --git a/public/md-articles/dotkernel/using-dotkernel-with-composer-dependencies.md b/public/md-articles/dotkernel/using-dotkernel-with-composer-dependencies.md
index ffafde13..3244bf82 100644
--- a/public/md-articles/dotkernel/using-dotkernel-with-composer-dependencies.md
+++ b/public/md-articles/dotkernel/using-dotkernel-with-composer-dependencies.md
@@ -11,67 +11,52 @@ language: "en"
 # Using Dotkernel with Composer Dependencies
 
 ## TL;DR
+
 This article covers using external dependencies via Composer within Dotkernel applications.
 Composer autoloads dependencies automatically, so there is no need to include/require them.
 The example renders a Barcode using Zend Framework 1 (non-namespaced) and Zend Framework 2 (namespaced), and applies to any Dotkernel 1.x version running PHP greater than 5.4.0.
 
-This article will cover the external dependency usage VIA composer within Dotkernel applications.
-
-There is also an article explaining how composer can be added to Dotkernel [learn more](http://www.dotkernel.com/dotkernel/adding-composer-support-in-your-dotkernel-project).
-
-Composer automatically loads our dependencies so there is no need to include/require them.
-
-For this example we will render a Barcode using [Zend Framework 1](http://framework.zend.com/manual/1.12/en/manual.html) as the Non-Namespaced dependency and [Zend Framework 2](http://framework.zend.com/manual/current/en/index.html) as the Namespaced dependency.
-
 ## The Composer Dependencies
 
-ZendFramework 1 Barcode module can only be loaded with the ZF1 itself:
+The ZendFramework 1 Barcode module can only be loaded with ZF1 itself:
 
-```
+```shell
 composer require 'zendframework/zendframework1'
 ```
 
-The ZendFramework 2 Barcode module can be separately loaded:
+The ZendFramework 2 Barcode module can be loaded separately:
 
-```
+```shell
 composer require 'zendframework/zend-barcode'
 ```
 
- 
-
 ## Important note
 
-```
-These dependencies can be used anywhere after the Dot_Kernel::initialize() function was called
-```
-
- 
+These dependencies can be used anywhere after the `Dot_Kernel::initialize()` function was called.
 
 ## Using Non-Namespaced Dependencies (Zend Framework 1)
 
-The class is loaded [PSR-0](http://www.php-fig.org/psr/psr-0/) style, meaning the class name looks like VendorName_PackageName_ClassName
+The class is loaded [PSR-0](http://www.php-fig.org/psr/psr-0/) style, meaning the class name looks like `VendorName_PackageName_ClassName`:
 
-```
+```php
 // Only the text to draw is required
-$barcodeOptions = array('text' =>; 'ZEND-FRAMEWORK');
- 
+$barcodeOptions = array('text' => 'ZEND-FRAMEWORK');
+
 // No required options
 $rendererOptions = array();
- 
+
 // Draw the barcode in a new image,
 // send the headers and the image
 Zend_Barcode::factory(
-'code39', 'image', $barcodeOptions, $rendererOptions
+    'code39', 'image', $barcodeOptions, $rendererOptions
 )->render();
 ```
 
- 
-
 ## Using Namespaced Dependencies (Zend Framework 2)
 
-The class is loaded [PSR-4](http://www.php-fig.org/psr/psr-4/) style, meaning the class name looks like \VendorName\PackageName\ClassName
+The class is loaded [PSR-4](http://www.php-fig.org/psr/psr-4/) style, meaning the class name looks like `\VendorName\PackageName\ClassName`:
 
-```
+```php
 use Zend\Barcode\Barcode;
 
 // Only the text to draw is required
@@ -89,36 +74,27 @@ Barcode::factory(
 
 ### The result
 
-Both the examples will render the following barcode if nothing goes wrong:
+Both examples render the same barcode.
 
-[![Resulting barcode. Source: http://framework.zend.com/images/manual/zend.barcode.introduction.example-1.png](/uploads/article/019f8a80-cc48-70bf-ba9f-ddc6d1436f1a/zend.barcode.introduction.example-1.png)](/uploads/2016/04/zend.barcode.introduction.example-1.png) Resulting barcode.
-Source: bit.ly/1XbZZ81
+[![Resulting barcode.](/uploads/article/019f8a80-cc48-70bf-ba9f-ddc6d1436f1a/zend.barcode.introduction.example-1.png)](/uploads/2016/04/zend.barcode.introduction.example-1.png)
 
 ### Tip
 
-In this case the first example will work for both namespaced an non-namespaced dependencies if we add the the following as the first line at the first example:
+The first (ZF1-style) example will work for both namespaced and non-namespaced dependencies if you add this as the first line:
 
-```
+```php
 use Zend\Barcode\Barcode as Zend_Barcode;
 ```
 
-Now we can use any of the following to access ZF2's Barcode Module:
+You can then use any of the following to access ZF2's Barcode module:
 
-- Zend\Barcode\Barcode
-- Barcode
-- Zend_Barcode
+- `Zend\Barcode\Barcode`
+- `Barcode`
+- `Zend_Barcode`
 
- 
+## Compatibility
 
- 
-
-The full examples can be found here:
-
-[Zend Framework 1 - Rendering a barcode](http://framework.zend.com/manual/1.12/en/zend.barcode.creation.html#zend.barcode.creation.renderering)
-
-[Zend Framework 2 - Rendering a barcode](http://framework.zend.com/manual/current/en/modules/zend.barcode.creation.html#rendering-a-barcode)
-
-This article works for any **Dotkernel 1.x** version if your server is running **PHP >5.4.0.**
+This article works for any Dotkernel 1.x version if your server is running PHP greater than 5.4.0.
 
 ## FAQ
 
@@ -126,16 +102,28 @@ This article works for any **Dotkernel 1.x** version if your server is running *
 A: No. Composer automatically loads dependencies, so there is no need to include or require them yourself.
 
 **Q: What example does the article use to demonstrate Composer dependencies?**
-A: The article renders a Barcode using Zend Framework 1 as the Non-Namespaced dependency (installed with composer require 'zendframework/zendframework1') and Zend Framework 2 as the Namespaced dependency (installed with composer require 'zendframework/zend-barcode').
+A: The article renders a Barcode using Zend Framework 1 as the Non-Namespaced dependency (installed with `composer require 'zendframework/zendframework1'`) and Zend Framework 2 as the Namespaced dependency (installed with `composer require 'zendframework/zend-barcode'`).
 
 **Q: When can these Composer dependencies be used in the application?**
 A: These dependencies can be used anywhere after the Dot_Kernel::initialize() function has been called.
 
 **Q: How are non-namespaced (Zend Framework 1) classes loaded compared to namespaced (Zend Framework 2) classes?**
-A: Non-namespaced ZF1 classes are loaded PSR-0 style, meaning the class name looks like VendorName_PackageName_ClassName (e.g. Zend_Barcode). Namespaced ZF2 classes are loaded PSR-4 style, meaning the class name looks like \VendorName\PackageName\ClassName (e.g. Zend\Barcode\Barcode).
+A: Non-namespaced ZF1 classes are loaded PSR-0 style, meaning the class name looks like VendorName_PackageName_ClassName (e.g. Zend_Barcode).
+Namespaced ZF2 classes are loaded PSR-4 style, meaning the class name looks like \VendorName\PackageName\ClassName (e.g. Zend\Barcode\Barcode).
 
 **Q: Can the same code work for both namespaced and non-namespaced barcode dependencies?**
-A: Yes. If you add "use Zend\Barcode\Barcode as Zend_Barcode;" as the first line, the ZF1-style example will work for both, and you can then reference the module as Zend\Barcode\Barcode, Barcode, or Zend_Barcode.
+A: Yes.
+If you add "use Zend\Barcode\Barcode as Zend_Barcode;" as the first line, the ZF1-style example will work for both, and you can then reference the module as Zend\Barcode\Barcode, Barcode, or Zend_Barcode.
 
 **Q: What Dotkernel and PHP versions does this article apply to?**
 A: This article works for any Dotkernel 1.x version if your server is running PHP greater than 5.4.0.
+
+## Resources
+
+- [Adding Composer support in your Dotkernel project](http://www.dotkernel.com/dotkernel/adding-composer-support-in-your-dotkernel-project)
+- [Zend Framework 1 manual](http://framework.zend.com/manual/1.12/en/manual.html)
+- [Zend Framework 2 manual](http://framework.zend.com/manual/current/en/index.html)
+- [PSR-0](http://www.php-fig.org/psr/psr-0/)
+- [PSR-4](http://www.php-fig.org/psr/psr-4/)
+- [Zend Framework 1 - Rendering a barcode](http://framework.zend.com/manual/1.12/en/zend.barcode.creation.html#zend.barcode.creation.renderering)
+- [Zend Framework 2 - Rendering a barcode](http://framework.zend.com/manual/current/en/modules/zend.barcode.creation.html#rendering-a-barcode)
diff --git a/public/md-articles/dotkernel/using-utf8-charset-in-dotkernel.md b/public/md-articles/dotkernel/using-utf8-charset-in-dotkernel.md
index 116586a6..2c3844e5 100644
--- a/public/md-articles/dotkernel/using-utf8-charset-in-dotkernel.md
+++ b/public/md-articles/dotkernel/using-utf8-charset-in-dotkernel.md
@@ -11,36 +11,36 @@ language: "en"
 # Using UTF8 charset in Dotkernel
 
 ## TL;DR
+
 To use UTF8 encoding in a Dotkernel-based system, changes are needed in both the database structure and the application.ini file.
 These changes were committed into the Dotkernel 1.6.0 dev codebase.
 
-In order to use UTF8 encoding in your Dotkernel based system, is needed to make some changes in both database structure and in the application.ini file.
-
-> Those changes are commited into **Dotkernel 1.6.0 dev** codebase, which will be released in next days.
-
 ## Database
 
-set for all tables and columns proper collation , either **utf8_general_ci** or **utf8_bin**
+Set a proper collation for all tables and columns, either **utf8_general_ci** or **utf8_bin**.
 
-## Application.ini
+## application.ini
 
-add the line
+Add the following line to your application.ini file, in the database area:
 
-```
+```ini
 database.params.charset = utf8
 ```
 
-to your application.ini file, in the **[production]** area.
-
 ## Differences between utf8_general_ci and utf8_bin
 
-**utf8_bin**: compare strings by the binary value of each character in the string **utf8_general_ci**: compare strings using general language rules and using case-insensitive comparisons
+| Collation | Behavior |
+|---|---|
+| utf8_bin | Compares strings by the binary value of each character in the string |
+| utf8_general_ci | Compares strings using general language rules and case-insensitive comparisons |
 
-For example, the following will evaluate at true with  utf8_general_ci collation, but **not** with the utf8_bin collation:
+For example, the following evaluates as true with utf8_general_ci collation, but **not** with utf8_bin collation:
 
-Ä = A Ö = O Ü = U
+- Ä = A
+- Ö = O
+- Ü = U
 
-Those differences happens only on **MySQL** level ( for instance in queries using LIKE operator) and **not** at **PHP** level ( for instance, in str_replace() calls )
+These differences only happen at the **MySQL** level (for instance, in queries using the LIKE operator) and **not** at the **PHP** level (for instance, in `str_replace()` calls).
 
 ## FAQ
 
@@ -48,10 +48,11 @@ Those differences happens only on **MySQL** level ( for instance in queries usin
 A: Both the database structure and the application.ini file need changes: all tables and columns must have a proper UTF8 collation (utf8_general_ci or utf8_bin), and application.ini must load the utf8 charset.
 
 **Q: What line should I add to application.ini to enable UTF8?**
-A: Add the line database.params.charset = utf8 to your application.ini file.
+A: Add the line `database.params.charset = utf8` to your application.ini file.
 
 **Q: What is the difference between utf8_general_ci and utf8_bin collation?**
-A: utf8_bin compares strings by the binary value of each character, while utf8_general_ci compares strings using general language rules with case-insensitive comparisons. For example, Ä = A, Ö = O, and Ü = U evaluate as true under utf8_general_ci but not under utf8_bin.
+A: utf8_bin compares strings by the binary value of each character, while utf8_general_ci compares strings using general language rules with case-insensitive comparisons.
+For example, Ä = A, Ö = O, and Ü = U evaluate as true under utf8_general_ci but not under utf8_bin.
 
 **Q: Does the collation choice affect PHP string functions too?**
 A: No. These collation differences only happen at the MySQL level, for instance in queries using the LIKE operator, and not at the PHP level, for instance in str_replace() calls.
diff --git a/public/md-articles/dotkernel/wurfl-cloud-integration-in-dotkernel-1-6-0.md b/public/md-articles/dotkernel/wurfl-cloud-integration-in-dotkernel-1-6-0.md
index 359e75ad..b05c5c9a 100644
--- a/public/md-articles/dotkernel/wurfl-cloud-integration-in-dotkernel-1-6-0.md
+++ b/public/md-articles/dotkernel/wurfl-cloud-integration-in-dotkernel-1-6-0.md
@@ -11,40 +11,44 @@ language: "en"
 # Wurfl Cloud Integration in Dotkernel 1.6.0
 
 ## TL;DR
-Dotkernel 1.6.0 integrates Wurfl Cloud, WURFL's (Wireless Universal Resource FiLe) new cloud-based way of delivering device detection services, as its default method for detecting mobile devices.
-
-Another new feature in version 1.6.0 of Dotkernel is the integration of Wurfl Cloud.
 
-Wurfl or Wireless Universal Resource FiLe is coming with a new way to deliver their services of device detection and they named it Wurfl Cloud.
+Dotkernel 1.6.0 integrates Wurfl Cloud, WURFL's (Wireless Universal Resource FiLe) new cloud-based way of delivering device detection services, as its default method for detecting mobile devices.
 
-Because of the need to detect mobile devices in Dotkernel we have integrated Wurfl Cloud as the default detection method.
+## Where to find it
 
-If you want to see the Wurfl Cloud library you can find it in the library folder of Dotkernel.
+The Wurfl Cloud library can be found in the library folder of Dotkernel.
 
-Quick steps to have a functional device detection in Dotkernel.
+## Quick steps to a functional device detection setup
 
-- register for an Wurfl Cloud account [here](https://www.scientiamobile.com/register)
-- choose **device_os** and **mobile_browser** as your capabilities
-- copy your API Key in application.ini in Dotkernel
+1. Register for a Wurfl Cloud account [here](https://www.scientiamobile.com/register).
+2. Choose **device_os** and **mobile_browser** as your capabilities.
+3. Copy your API key into application.ini in Dotkernel:
 
-```
+```ini
 resources.useragent.wurflcloud.api_key = 000000:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 ```
 
-Now you can test it by changing the user agent in your browser to a mobile device and access your project. Now you can see that you are redirected to the mobile module.
+## Testing it
 
-To see how mobile detection is working in Dotkernel read this [post](http://www.dotkernel.com/?p=1465).
+Change the user agent in your browser to a mobile device and access your project.
+You should be redirected to the mobile module.
 
 ## FAQ
 
 **Q: What is WURFL Cloud?**
-A: WURFL Cloud is a new way that WURFL (Wireless Universal Resource FiLe) delivers its device detection services. Dotkernel integrated it as the default detection method for mobile devices starting with version 1.6.0.
+A: WURFL Cloud is a new way that WURFL (Wireless Universal Resource FiLe) delivers its device detection services.
+Dotkernel integrated it as the default detection method for mobile devices starting with version 1.6.0.
 
 **Q: How do I get a functional device detection setup with WURFL Cloud?**
 A: Register for a Wurfl Cloud account with Scientia Mobile, choose device_os and mobile_browser as your capabilities, then copy your API key into application.ini in Dotkernel.
 
 **Q: What line do I add to application.ini for the API key?**
-A: Add a line such as resources.useragent.wurflcloud.api_key = 000000:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX, using your own API key.
+A: Add a line such as `resources.useragent.wurflcloud.api_key = 000000:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX`, using your own API key.
 
 **Q: How can I test that mobile detection is working?**
 A: Change the user agent in your browser to a mobile device and access your project; you should be redirected to the mobile module.
+
+## Resources
+
+- Register for a Wurfl Cloud account: https://www.scientiamobile.com/register
+- Related post - Detecting Mobile Devices in Dotkernel 1.6.0: http://www.dotkernel.com/?p=1465
diff --git a/public/md-articles/dotkernel/wurfl-php-api-license-incompatible-with-dotkernel.md b/public/md-articles/dotkernel/wurfl-php-api-license-incompatible-with-dotkernel.md
index 0990ee1a..6810e1ad 100644
--- a/public/md-articles/dotkernel/wurfl-php-api-license-incompatible-with-dotkernel.md
+++ b/public/md-articles/dotkernel/wurfl-php-api-license-incompatible-with-dotkernel.md
@@ -11,35 +11,48 @@ language: "en"
 # WURFL PHP API license incompatible with Dotkernel
 
 ## TL;DR
+
 The WURFL PHP API was integrated into Dotkernel long ago under a GNU/GPL license, compatible with Zend Framework's new BSD license and Dotkernel's OSL 3.0 license.
 On June 6th, 2011, WURFL PHP API version 1.3.0 changed its license to AGPL, turning it into a "trial only" library for product evaluation.
 Dotkernel had updated to this version in the 1.5.0 release candidate without noticing the license change.
 
-We integrated long time ago the WURFL PHP API into Dotkernel code base. At that time, the license of that WURFL library was GNU/GPL, which make it perfect compatible with Zend Framework license( **new BSD**) and Dotkernel ( **OSL 3.0**). Everybody was happy, users was able to make web applications for them or for their customers without worry about licensing costs at all.
+## What happened
 
-On June 6th, 2011, the WURFL PHP API library was updated to version 1.3.0. So we updated too the latest Dotkernel 1.5.0 ( now in release candidate stage, soon to be released as stable) , without noticing the change on its license, from GNU/GPL to AGPL which suddenly transform it into a 'trial only' library, for "Product evaluation" only.
+We integrated the WURFL PHP API into the Dotkernel code base a long time ago.
+At that time its license was GNU/GPL, perfectly compatible with the Zend Framework license (new BSD) and Dotkernel (OSL 3.0).
+On June 6th, 2011, the WURFL PHP API library was updated to version 1.3.0, and Dotkernel followed suit in its 1.5.0 release candidate, without noticing that the license had changed from GNU/GPL to AGPL - suddenly turning it into a "trial only" library for "Product evaluation" only.
 
-See the official announcement [**here**](http://www.scientiamobile.com/site/page/view/products#licenses).
+See the [official announcement](http://www.scientiamobile.com/site/page/view/products#licenses).
 
-We respect the work of Luca Passani and Steve Kamerman ( thank you and keep up the good work :-) ). But we must keep [Dotkernel Application Framework](http://www.dotkernel.com) free, without such license limitations. Only thing to do in this stage is :
+## What Dotkernel plans to do
 
-- remove WURFL PHP API library version 1.3.0 from Dotkernel code base
-- integrate back version 1.2.1 which is still GNU/GPL
-- we are still collecting device informations, so we will contribute to WURFL XML data which remain free. This file, which represent the data itself, it is and must be the **industry standard**
-- fork WURFL PHP APi 1.2.1 to a new library maybe ?
-- change the name of that library to avoid trademark issues ?
+We respect the work of Luca Passani and Steve Kamerman, but we must keep [Dotkernel Application Framework](http://www.dotkernel.com) free, without such license limitations.
+The only things to do at this stage are:
 
- 
+- Remove WURFL PHP API library version 1.3.0 from the Dotkernel code base.
+- Integrate back version 1.2.1, which is still GNU/GPL.
+- Keep collecting device information and contributing to the WURFL XML data, which remains free - this data file is and must be the industry standard.
+- Consider forking WURFL PHP API 1.2.1 to a new library.
+- Consider changing the library's name to avoid trademark issues.
 
-*later edit: the correct link to announcement is **[here](http://tech.groups.yahoo.com/group/wmlprogramming/message/34031)***
+*Later edit: the correct link to the announcement is [here](http://tech.groups.yahoo.com/group/wmlprogramming/message/34031).*
 
 ## FAQ
 
 **Q: Why did the WURFL PHP API license become incompatible with Dotkernel?**
-A: The WURFL PHP API used to be licensed under GNU/GPL, compatible with both Zend Framework's new BSD license and Dotkernel's OSL 3.0 license. On June 6th, 2011, version 1.3.0 of the library changed its license to AGPL, turning it into a "trial only" library for product evaluation, which is incompatible with keeping Dotkernel free.
+A: The WURFL PHP API used to be licensed under GNU/GPL, compatible with both Zend Framework's new BSD license and Dotkernel's OSL 3.0 license.
+On June 6th, 2011, version 1.3.0 of the library changed its license to AGPL, turning it into a trial-only library for product evaluation, which is incompatible with keeping Dotkernel free.
 
 **Q: Which version introduced the license change, and when?**
-A: Version 1.3.0 of the WURFL PHP API, released June 6th, 2011, changed the license from GNU/GPL to AGPL. Dotkernel had updated to this version in its 1.5.0 release candidate without noticing the license change.
+A: Version 1.3.0 of the WURFL PHP API, released June 6th, 2011, changed the license from GNU/GPL to AGPL.
+Dotkernel had updated to this version in its 1.5.0 release candidate without noticing the license change.
 
 **Q: What did Dotkernel do in response to the license change?**
-A: Dotkernel planned to remove WURFL PHP API version 1.3.0 from its codebase and reintegrate version 1.2.1, which was still GNU/GPL. It also intended to keep contributing to the free WURFL XML data, and considered forking the 1.2.1 library and renaming it to avoid trademark issues.
+A: Dotkernel planned to remove WURFL PHP API version 1.3.0 from its codebase and reintegrate version 1.2.1, which was still GNU/GPL.
+It also intended to keep contributing to the free WURFL XML data, and considered forking the 1.2.1 library and renaming it to avoid trademark issues.
+
+## Resources
+
+- Official announcement of the license change: http://www.scientiamobile.com/site/page/view/products#licenses
+- Corrected announcement link: http://tech.groups.yahoo.com/group/wmlprogramming/message/34031
+- Dotkernel Application Framework: http://www.dotkernel.com
diff --git a/public/md-articles/dotkernel/wurfl-zend-framework-integration-into-dotkernel.md b/public/md-articles/dotkernel/wurfl-zend-framework-integration-into-dotkernel.md
index e853444f..ddbc155d 100644
--- a/public/md-articles/dotkernel/wurfl-zend-framework-integration-into-dotkernel.md
+++ b/public/md-articles/dotkernel/wurfl-zend-framework-integration-into-dotkernel.md
@@ -11,42 +11,43 @@ language: "en"
 # WURFL Zend Framework Integration into Dotkernel
 
 ## TL;DR
+
 [WURFL](http://wurfl.sourceforge.net/) is integrated into Dotkernel using the [Zend_Http_UserAgent](http://framework.zend.com/manual/1.11/en/zend.http.user-agent.html) class from [ZF 1.11.0rc1](http://framework.zend.com/download/latest) (the beta release at the time of the post).
 This post walks through the required folders, config files, and code to wire it up.
 
-[WURFL](http://wurfl.sourceforge.net/) is integrated into Dotkernel, using the [Zend_Http_UserAgent](http://framework.zend.com/manual/1.11/en/zend.http.user-agent.html) class from the latest release [ZF 1.11.0rc1](http://framework.zend.com/download/latest) ( Beta release at the date of this post).
-
-The integration of [WURFL](http://wurfl.sourceforge.net/) into Dotkernel is described below.
+## Installation steps
 
-Download [WURFL PHP API](http://sourceforge.net/projects/wurfl/files/WURFL%20PHP/1.1/wurfl-php-1.1.tar.gz/download) and unzip it into folder ***wurfl-php-1.1***
+1. Download the [WURFL PHP API](http://sourceforge.net/projects/wurfl/files/WURFL%20PHP/1.1/wurfl-php-1.1.tar.gz/download) and unzip it into a folder named `wurfl-php-1.1`.
+2. Create the following folders and make them writable by the web server:
+   - `cache\wurfl\FILE_CACHE_PROVIDER`
+   - `cache\wurfl\FILE_PERSISTENCE_PROVIDER`
+3. In the `configs` folder:
+   - Copy `wurfl-config.xml` from `wurfl-php-1.1\examples\resources`.
+   - Rename `wurfl-config.xml` to `wurfl.xml`.
+4. Edit the `configs\application.ini` file and add these lines:
 
-- Create folders and make it **writable** by web server
-  - ***cache\wurfl\FILE_CACHE_PROVIDER***
-  - ***cache\wurfl\FILE_PERSISTENCE_PROVIDER***
-- In folder *configs*:
-  - Copy ***wurfl-config.xml*** from ***wurfl-php-1.1\examples\resources***
-  - Rename ***wurfl-config.xml*** to ***wurfl.xml***
-- Edit ***configs\application.ini***file; add these lines:
-
-```
+```ini
 resources.useragent.wurflapi.wurfl_api_version = "1.1"
 resources.useragent.wurflapi.wurfl_lib_dir = APPLICATION_PATH "/library/Wurfl/"
 resources.useragent.wurflapi.wurfl_config_file = APPLICATION_PATH "/configs/wurfl.xml"
 ```
 
-- Create folder ***externals\wurfl***, and copy the following files from:
-  - ***wurfl-php-1.1\examples\resources\web_browsers_patch.xml***
-  - ***wurfl-php-1.1\examples\resources\wurfl-regression.zip*** and rename it ***wurfl.zip*** or download the [latest wurfl zip](http://sourceforge.net/projects/wurfl/files/WURFL/) database and rename it ***wurfl.zip***
-- Copy the contents of the folder ***wurfl-php-1.1\WURFL*** to ***library\Wurfl***
+5. Create the folder `externals\wurfl`, and copy the following files into it:
+   - `wurfl-php-1.1\examples\resources\web_browsers_patch.xml`
+   - `wurfl-php-1.1\examples\resources\wurfl-regression.zip`, renamed to `wurfl.zip` (or download the [latest wurfl zip](http://sourceforge.net/projects/wurfl/files/WURFL/) database and rename it `wurfl.zip`).
+6. Copy the contents of the folder `wurfl-php-1.1\WURFL` to `library\Wurfl`.
 
-[WURFL](http://wurfl.sourceforge.net/) is integrated into Dotkernel in the mobile module, but to access WURFL configuration, use
+## Using WURFL in Dotkernel
 
-```
+[WURFL](http://wurfl.sourceforge.net/) is integrated into Dotkernel in the mobile module.
+To access WURFL configuration:
+
+```php
 $userAgent = new Zend_Http_UserAgent($config->resources->useragent);
 $device = $userAgent->getDevice();
 ```
 
-*$userAgent->getDevice()* returns all the relevant information about the current user agent *($_SERVER['HTTP_USER_AGENT'])*
+`$userAgent->getDevice()` returns all the relevant information about the current user agent (`$_SERVER`).
 
 ## FAQ
 
@@ -63,4 +64,12 @@ A: Two folders must be created and made writable by the web server: cache/wurfl/
 A: Three lines need to be added: resources.useragent.wurflapi.wurfl_api_version = "1.1", resources.useragent.wurflapi.wurfl_lib_dir pointing to APPLICATION_PATH "/library/Wurfl/", and resources.useragent.wurflapi.wurfl_config_file pointing to APPLICATION_PATH "/configs/wurfl.xml".
 
 **Q: How do you access WURFL configuration in code?**
-A: Instantiate a Zend_Http_UserAgent with the useragent config, then call getDevice() on it, for example $userAgent = new Zend_Http_UserAgent($config->resources->useragent); $device = $userAgent->getDevice();. getDevice() returns all the relevant information about the current user agent.
+A: Instantiate a Zend_Http_UserAgent with the useragent config, then call getDevice() on it. getDevice() returns all the relevant information about the current user agent.
+
+## Resources
+
+- WURFL: http://wurfl.sourceforge.net/
+- Zend_Http_UserAgent manual: http://framework.zend.com/manual/1.11/en/zend.http.user-agent.html
+- Zend Framework latest download: http://framework.zend.com/download/latest
+- WURFL PHP API 1.1 download: http://sourceforge.net/projects/wurfl/files/WURFL%20PHP/1.1/wurfl-php-1.1.tar.gz/download
+- Latest WURFL zip database: http://sourceforge.net/projects/wurfl/files/WURFL/
diff --git a/public/md-articles/dotkernel/zend-auth-and-zend-acl-integrated-in-dotkernel.md b/public/md-articles/dotkernel/zend-auth-and-zend-acl-integrated-in-dotkernel.md
index ff375f0d..1de42fcf 100644
--- a/public/md-articles/dotkernel/zend-auth-and-zend-acl-integrated-in-dotkernel.md
+++ b/public/md-articles/dotkernel/zend-auth-and-zend-acl-integrated-in-dotkernel.md
@@ -11,16 +11,15 @@ language: "en"
 # Zend_Auth and Zend_Acl integrated in Dotkernel
 
 ## TL;DR
+
 [Zend_Auth](http://framework.zend.com/manual/en/zend.auth.html) and [Zend_Acl](http://framework.zend.com/manual/en/zend.acl.html) have been integrated into Dotkernel starting with version 1.5.0.
 The User and Admin models were completely refactored using the new `Dot_Auth` and `Dot_Acl` classes for authentication and access control.
 
-[Zend_Auth](http://framework.zend.com/manual/en/zend.auth.html) and [Zend_Acl](http://framework.zend.com/manual/en/zend.acl.html) have been integrated into the Dotkernel, starting with version 1.5.0
-
-With the integration of these two major components for user authorization and access we completely refactored the User and Admin models by using *Dot_Auth* and *Dot_Acl* classes.
+## Dot_Auth
 
-The *Dot_Auth* class authenticates the user by checking the database – *Zend_Auth_Adapter_DbTable*.
+The `Dot_Auth` class authenticates the user by checking the database, using `Zend_Auth_Adapter_DbTable`:
 
-```
+```php
 private function _getAuthAdapter($who)
     {
         $dbAdapter = Zend_Registry::get('database');
@@ -32,22 +31,26 @@ private function _getAuthAdapter($who)
     }
 ```
 
-ACL roles (user types) and permissions are configured in the *configs/acl/role.xml* file. In Dotkernel there are 3 roles: *guest*, *user* and *admin*. The resources for ACL are taken from *configs/router.xml* – see *controllers* tag.
+## ACL roles and resources
 
-The *Dot_Acl* class
+ACL roles (user types) and permissions are configured in the `configs/acl/role.xml` file.
+In Dotkernel there are 3 roles: `guest`, `user`, and `admin`.
+The resources for ACL are taken from `configs/router.xml` - see the `controllers` tag.
 
-- controls the user access (ACL – Access Controller Layer),
-- is used for setting and checking the permissions of a user*,*
-- uses Zend_Acl,  for checking if a role (user) has access to a resource (controller)
+## Dot_Acl
 
-*Dot_Auth* calls the *isAllowed* method from *Dot_Acl* which authenticates the user.
+The `Dot_Acl` class:
 
-```
+- Controls user access (ACL - Access Controller Layer).
+- Is used for setting and checking the permissions of a user.
+- Uses Zend_Acl for checking if a role (user) has access to a resource (controller).
+
+```php
 // instantiate Zend_Acl
 $this->acl = new Zend_Acl();
 ```
 
-```
+```php
 public function isAllowed($role)
     {
         $resource = $this->requestControllerProcessed;
@@ -63,9 +66,10 @@ public function isAllowed($role)
     }
 ```
 
-*IndexController.php* is calling *Dot_Auth*
+`Dot_Auth` calls the `isAllowed` method from `Dot_Acl` which authenticates the user.
+`IndexController.php` calls `Dot_Auth`:
 
-```
+```php
 $dotAuth = Dot_Auth::getInstance();
 $dotAuth->checkIdentity('user');
 ```
@@ -76,13 +80,20 @@ $dotAuth->checkIdentity('user');
 A: Zend_Auth and Zend_Acl were integrated starting with Dotkernel version 1.5.0, as part of a refactor of the User and Admin models using the new Dot_Auth and Dot_Acl classes.
 
 **Q: How does Dot_Auth authenticate a user?**
-A: Dot_Auth authenticates the user by checking the database using Zend_Auth_Adapter_DbTable, setting the table name, the identity column to "username", and the credential column to "password".
+A: Dot_Auth authenticates the user by checking the database using Zend_Auth_Adapter_DbTable, setting the table name, the identity column to username, and the credential column to password.
 
 **Q: What roles exist for ACL in Dotkernel?**
-A: Dotkernel defines 3 ACL roles (user types): guest, user, and admin. These roles and their permissions are configured in the configs/acl/role.xml file.
+A: Dotkernel defines 3 ACL roles (user types): guest, user, and admin.
+These roles and their permissions are configured in the configs/acl/role.xml file.
 
 **Q: Where do the ACL resources come from?**
 A: The resources for ACL are taken from configs/router.xml, specifically the controllers tag.
 
 **Q: What does the Dot_Acl class do?**
-A: Dot_Acl controls user access (Access Controller Layer), is used for setting and checking a user's permissions, and uses Zend_Acl to check whether a role (user) has access to a resource (controller). Dot_Auth calls the isAllowed method from Dot_Acl to authenticate the user.
+A: Dot_Acl controls user access (Access Controller Layer), is used for setting and checking a user's permissions, and uses Zend_Acl to check whether a role has access to a resource.
+Dot_Auth calls the isAllowed method from Dot_Acl to authenticate the user.
+
+## Resources
+
+- Zend_Auth manual: http://framework.zend.com/manual/en/zend.auth.html
+- Zend_Acl manual: http://framework.zend.com/manual/en/zend.acl.html
diff --git a/public/md-articles/dotkernel/zend-console-implementation-in-dotkernel.md b/public/md-articles/dotkernel/zend-console-implementation-in-dotkernel.md
index d110ddba..acf47113 100644
--- a/public/md-articles/dotkernel/zend-console-implementation-in-dotkernel.md
+++ b/public/md-articles/dotkernel/zend-console-implementation-in-dotkernel.md
@@ -11,31 +11,34 @@ language: "en"
 # Zend_Console implementation in Dotkernel
 
 ## TL;DR
+
 Starting with version 1.5, Dotkernel has a Console bootstrap to easily run PHP scripts from the command line.
 The most common use for this is running cron jobs without using wget or going through Apache.
 
-Starting with 1.5, Dotkernel has a Console bootstrap to easily run PHP scripts from the command line. The most common use for this is to be able to run cron jobs without using wget and going through Apache.
+## Where it lives
 
-The bootstrap can be found in *Console/index.php* and it has one controller in *Controller.php* with two example actions.
+The bootstrap can be found in `Console/index.php`, and it has one controller in `Controller.php` with two example actions.
 
 ## Usage
 
-Currently there are two command line arguments:
+There are two command line arguments:
 
-- **-a** [action] - the name of the action that will be executed
-- **-e** [environment] - the environment, as defined in application.ini. Possible values are development, staging and production. This argument is optional, it defaults to production
+| Argument | Meaning |
+|---|---|
+| `-a` | The name of the action that will be executed |
+| `-e` | The environment, as defined in application.ini. Possible values are development, staging, and production. Optional, defaults to production |
 
-Any other arguments set when calling the script will be available in the controller in the $registry->arguments array.
+Any other arguments set when calling the script will be available in the controller in the `$registry->arguments` array.
 
-The controller bundled with Dotkernel has two example actions, "count-users" which demonstrates how to interact with models, and "send-newsletter" which reads the newsletter from the command line.
+The controller bundled with Dotkernel has two example actions: `count-users`, which demonstrates how to interact with models, and `send-newsletter`, which reads the newsletter from the command line.
 
 ## Examples
 
-```
+```shell
 /var/www/vhosts/example.com/httpdocs/Cron/index.php -e staging -a count-users
 ```
 
-```
+```shell
 /var/www/vhosts/example.com/httpdocs/Cron/index.php -e staging -a send-newsletter "test newsletter"
 ```
 
@@ -51,7 +54,7 @@ A: The bootstrap is found in Console/index.php, and it has one controller in Con
 A: There are two arguments: -a, the name of the action to execute, and -e, the environment as defined in application.ini (development, staging, or production), which is optional and defaults to production.
 
 **Q: What happens to extra arguments passed to the script?**
-A: Any other arguments set when calling the script will be available in the controller in the $registry->arguments array.
+A: Any other arguments set when calling the script will be available in the controller in the `$registry->arguments` array.
 
 **Q: What example actions are bundled with the Console controller?**
-A: The bundled controller has two example actions: "count-users", which demonstrates how to interact with models, and "send-newsletter", which reads the newsletter from the command line.
+A: The bundled controller has two example actions: count-users, which demonstrates how to interact with models, and send-newsletter, which reads the newsletter from the command line.
diff --git a/public/md-articles/dotkernel/zend-framework-dropped-integration-of-wurfl-adapter.md b/public/md-articles/dotkernel/zend-framework-dropped-integration-of-wurfl-adapter.md
index 705a557a..0bf08cf6 100644
--- a/public/md-articles/dotkernel/zend-framework-dropped-integration-of-wurfl-adapter.md
+++ b/public/md-articles/dotkernel/zend-framework-dropped-integration-of-wurfl-adapter.md
@@ -10,15 +10,21 @@ language: "en"
 
 # Zend Framework dropped integration of WURFL adapter
 
-According to Matthew Weier O'Phinney, Zend Framework Project Leader, in the next release of ZF, 1.12.0 branch, WURFL adapter will be dropped
+## What happened
 
-> due to a change in licensing by the WURFL project -- the free version is now AGPL -- we're dropping the WURFL adapter from Zend_Http_UserAgent. In discussions with Zend and the CR Team, we feel the AGPL raises too many concerns for end users with regards to how their products must be licensed in order to comply. (This is a similar rationale as to why we did not consider ExtJS when looking at JS toolkits to partner with.)
-> 
+According to Matthew Weier O'Phinney, Zend Framework Project Leader, the WURFL adapter will be dropped from `Zend_Http_UserAgent` in the next release of ZF, the 1.12.0 branch:
+
+> due to a change in licensing by the WURFL project -- the free version is now AGPL -- we're dropping the WURFL adapter from Zend_Http_UserAgent.
+> In discussions with Zend and the CR Team, we feel the AGPL raises too many concerns for end users with regards to how their products must be licensed in order to comply.
+> (This is a similar rationale as to why we did not consider ExtJS when looking at JS toolkits to partner with.)
+>
 > As such, if you relied on the WURFL adapter in the past, you _will_ need to change code when upgrading to ZF 1.12.0, or grab the WURFL adapter from a previous version.
 
-So its a good moment to check the old or current projects, and proceed.
+So it's a good moment to check old or current projects, and proceed accordingly.
+
+## Impact on Dotkernel
 
-Dotkernel framework is using its own WURFL adapter, so this will not affect projects built with it .
+Dotkernel framework uses its own WURFL adapter, so this change will not affect projects built with it.
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel/zend-registry-usage-in-dotkernel.md b/public/md-articles/dotkernel/zend-registry-usage-in-dotkernel.md
index 48dd8464..bee393bc 100644
--- a/public/md-articles/dotkernel/zend-registry-usage-in-dotkernel.md
+++ b/public/md-articles/dotkernel/zend-registry-usage-in-dotkernel.md
@@ -11,24 +11,29 @@ language: "en"
 # Zend Registry usage in Dotkernel
 
 ## TL;DR
+
 In Dotkernel, `Zend_Registry` holds a fixed set of request-scoped variables - from timing and configuration to the database adapter and session object - and can be read either as a full instance or one value at a time.
 
-In Dotkernel, Zend_Registry will contain the following variables:
+## Variables stored in Zend_Registry
 
-- **startTime** - the result of [microtime()](http://php.net/manual/en/function.microtime.php) at the beginning of the request
-- **configuration** - the configuration options loaded from *configs/application.ini*
-- **router** - routing settings loaded from *configs/router.xml*
-- **database** - the database adapter
-- **settings** - the settings loaded from the database
-- **requestModule, requestController, requestAction** - the module, controller and action of the current request
-- **request** - additional request variables
-- **seo** - seo information loaded from *configs/dots/seo.xml* (site name, default description, keywords etc)
-- **option** - the options for the current dot loaded from *configs/dots/<moduleName>.xml*
-- **session** - the session object
+| Variable | Contents |
+|---|---|
+| `startTime` | The result of [microtime()](http://php.net/manual/en/function.microtime.php) at the beginning of the request |
+| `configuration` | The configuration options loaded from `configs/application.ini` |
+| `router` | Routing settings loaded from `configs/router.xml` |
+| `database` | The database adapter |
+| `settings` | The settings loaded from the database |
+| `requestModule, requestController, requestAction` | The module, controller, and action of the current request |
+| `request` | Additional request variables |
+| `seo` | SEO information loaded from `configs/dots/seo.xml` (site name, default description, keywords, etc.) |
+| `option` | The options for the current dot loaded from `configs/dots/<moduleName>.xml` |
+| `session` | The session object |
 
-To use the variables in the registry, you must first get an instance of the registry object:
+## Reading values from the registry
 
-```
+To use the variables in the registry, first get an instance of the registry object:
+
+```php
 $registry = Zend_Registry::getInstance();
 //...
 echo $registry->startTime;
@@ -36,24 +41,27 @@ echo $registry->startTime;
 echo $registry->requestAction;
 ```
 
-Or if you only need one variable from the registry, you can get it directly using:
+Or, if you only need one variable, get it directly:
 
-```
+```php
 $action = Zend_Registry::get('requestAction');
 ```
 
-You can find more information about Zend_Registry, in the [Zend Framework Documentation](http://framework.zend.com/manual/en/zend.registry.using.html).
-
 ## FAQ
 
 **Q: What variables does Zend_Registry contain in Dotkernel?**
 A: It contains startTime (the result of microtime() at the beginning of the request), configuration (loaded from configs/application.ini), router (loaded from configs/router.xml), database (the database adapter), settings (loaded from the database), requestModule/requestController/requestAction, request (additional request variables), seo (loaded from configs/dots/seo.xml), option (loaded from configs/dots/<moduleName>.xml), and session (the session object).
 
 **Q: How do you get an instance of the registry?**
-A: Use $registry = Zend_Registry::getInstance(); and then access variables such as $registry->startTime or $registry->requestAction.
+A: Use `$registry = Zend_Registry::getInstance();` and then access variables such as `$registry->startTime` or `$registry->requestAction`.
 
 **Q: How do you retrieve just one variable from the registry?**
-A: If you only need one variable, you can get it directly using $action = Zend_Registry::get('requestAction');.
+A: If you only need one variable, you can get it directly using `$action = Zend_Registry::get('requestAction');`.
 
 **Q: What does the "seo" entry in the registry contain?**
 A: It contains seo information loaded from configs/dots/seo.xml, such as site name, default description, and keywords.
+
+## Resources
+
+- microtime() PHP manual: http://php.net/manual/en/function.microtime.php
+- Zend Framework Documentation on Zend_Registry: http://framework.zend.com/manual/en/zend.registry.using.html
diff --git a/public/md-articles/dotkernel/zend-session-usage-in-dotkernel-refactor-of-dot-session-class.md b/public/md-articles/dotkernel/zend-session-usage-in-dotkernel-refactor-of-dot-session-class.md
index 291d6c96..a2207868 100644
--- a/public/md-articles/dotkernel/zend-session-usage-in-dotkernel-refactor-of-dot-session-class.md
+++ b/public/md-articles/dotkernel/zend-session-usage-in-dotkernel-refactor-of-dot-session-class.md
@@ -11,44 +11,60 @@ language: "en"
 # Zend_Session usage in Dotkernel - Refactor of Dot_Session class
 
 ## TL;DR
+
 A strange session bug was found on a project running Dotkernel 1.5.0: in IE8 and IE9, the session cookie was sometimes not saved, forcing repeated logins.
 Investigation traced it to the `Dot_Session` class calling both `regenerateID()` and `rememberMe()` unnecessarily, generating the session cookie 3 times.
 The fix, shipped in Dotkernel 1.5.1, removed the `regenerateID()` call and added two new application.ini settings.
 
-We found a strange behaviour of sessions in one of our project, running Dotkernel version 1.5.0
+## The bug
 
-Similar to this one described [here](http://trac.elgg.org/ticket/2677)
+We found a strange behaviour of sessions in one of our projects, running Dotkernel version 1.5.0 - similar to [one described here](http://trac.elgg.org/ticket/2677).
+In unknown circumstances, and only in IE 8 and IE9, the session cookie is not saved on the client machine, and the user needs to log in over and over again.
+It was reproduced once on the staging server, and the only way to fix it at the time was to open a new tab with the same page.
 
-In unknowns circumstances, and only in IE 8 and IE9 , the session cookie is not saved on client machine, and the user need to login over and over again. I was able to reproduce that behaviour once, on our staging server , and the only way to fix that was to **open a new tab with the same page (?!?!?)**
+## The investigation
 
-Anyway, is still an enygma. So i started to investigate Dot_Session class, and notice that the session cookie is generated **3 times !!** See this [bug report](http://www.dotkernel.net/view.php?id=184).
+Investigating the `Dot_Session` class showed that the session cookie is generated **3 times**.
+See this [bug report](http://www.dotkernel.net/view.php?id=184).
 
-I noticed that we use both **regenerateID()**  and **rememberMe()**  methods of Zend_Session, , which is   **not necessary** Quote from [ZF documentation](http://framework.zend.com/manual/1.11/en/zend.session.global_session_management.html):
+The code used both **regenerateID()** and **rememberMe()** methods of Zend_Session, which is **not necessary**.
+Quote from the [ZF documentation](http://framework.zend.com/manual/1.11/en/zend.session.global_session_management.html):
 
-> If you call the rememberMe() function, then don't use regenerateId(), since the former calls the latter.  If a user has successfully logged into your website, use rememberMe() instead of regenerateId().
+> If you call the rememberMe() function, then don't use regenerateId(), since the former calls the latter.
+> If a user has successfully logged into your website, use rememberMe() instead of regenerateId().
 
-So i removed **regenerateID()** call,   also added 2 new settings in application.ini  related to session : ***use_only_cookies***, which must be **ON** all the time in order to avoid *session fixation* , and **remember_me_seconds**.
+## The fix
 
-Those small bug fixes will be included in the new Dotkernel version 1.5.1 which will be released  next days.
+The **regenerateID()** call was removed, and 2 new settings were added in application.ini related to session:
 
-**TIP**
+- **use_only_cookies** - must be **ON** at all times in order to avoid session fixation.
+- **remember_me_seconds**.
 
-if you encounter the same issue in IE8 and IE9 , then with all regret, you need to de-activate the **rememberMe()** and **regenerateId()** methods calls.
+These bug fixes were included in the new Dotkernel version 1.5.1.
 
- 
+## Tip
 
- 
+If you encounter the same issue in IE8 and IE9, then with all regret, you need to deactivate the **rememberMe()** and **regenerateId()** methods calls.
 
 ## FAQ
 
 **Q: What session bug was found in Dotkernel 1.5.0?**
-A: In unknown circumstances, and only in IE8 and IE9, the session cookie was not saved on the client machine, forcing the user to log in over and over again. The only workaround found was to open a new tab with the same page.
+A: In unknown circumstances, and only in IE8 and IE9, the session cookie was not saved on the client machine, forcing the user to log in over and over again.
+The only workaround found was to open a new tab with the same page.
 
 **Q: What caused the session cookie to be generated multiple times?**
-A: Investigation of the Dot_Session class showed the session cookie was generated 3 times, because the code called both regenerateID() and rememberMe() methods of Zend_Session. According to the Zend Framework documentation, this is unnecessary: if you call rememberMe(), you should not also call regenerateId(), since rememberMe() already calls it internally.
+A: Investigation of the Dot_Session class showed the session cookie was generated 3 times, because the code called both regenerateID() and rememberMe() methods of Zend_Session.
+According to the Zend Framework documentation, this is unnecessary: if you call rememberMe(), you should not also call regenerateId(), since rememberMe() already calls it internally.
 
 **Q: What was the fix, and where was it released?**
-A: The regenerateID() call was removed, and two new application.ini settings were added: use_only_cookies, which must be ON at all times to avoid session fixation, and remember_me_seconds. These fixes were included in Dotkernel version 1.5.1.
+A: The regenerateID() call was removed, and two new application.ini settings were added: use_only_cookies, which must be ON at all times to avoid session fixation, and remember_me_seconds.
+These fixes were included in Dotkernel version 1.5.1.
 
 **Q: What should I do if I still see this issue in IE8/IE9?**
 A: If you encounter the same issue in IE8 and IE9, the tip given is to deactivate the rememberMe() and regenerateId() method calls.
+
+## Resources
+
+- Similar issue described on Elgg: http://trac.elgg.org/ticket/2677
+- Dotkernel bug report: http://www.dotkernel.net/view.php?id=184
+- Zend Framework documentation on global session management: http://framework.zend.com/manual/1.11/en/zend.session.global_session_management.html
diff --git a/public/md-articles/dotkernel/zend-studio-php-formatter-file-for-dotkernel-coding-standard.md b/public/md-articles/dotkernel/zend-studio-php-formatter-file-for-dotkernel-coding-standard.md
index d0337ccd..93272c54 100644
--- a/public/md-articles/dotkernel/zend-studio-php-formatter-file-for-dotkernel-coding-standard.md
+++ b/public/md-articles/dotkernel/zend-studio-php-formatter-file-for-dotkernel-coding-standard.md
@@ -10,11 +10,14 @@ language: "en"
 
 # Zend Studio PHP Formatter file for Dotkernel coding standard.
 
-[Here](http://www.dotkernel.com/download/?did=34) is  uploaded the XML file , ready to be imported in your Zend Studio, version 9.x
+An XML file is provided for download, ready to be imported into Zend Studio, version 9.x.
+This file follows Dotkernel's coding standard.
 
-This file follow Dotkernel’s Coding standard.
+## Installation steps
 
-Unzip the file. Go to Zend Studio -> Preferences -> PHP -> Code Style -> Formatter Import the xml file.
+1. Unzip the file.
+2. Go to Zend Studio -> Preferences -> PHP -> Code Style -> Formatter.
+3. Import the XML file.
 
 ## FAQ
 
@@ -23,3 +26,7 @@ A: It is an XML file, downloadable from the linked page, that can be imported in
 
 **Q: How do I import the formatter file into Zend Studio?**
 A: Unzip the downloaded file, then in Zend Studio go to Preferences -> PHP -> Code Style -> Formatter and import the XML file.
+
+## Resources
+
+- [Dotkernel PHP Formatter download](http://www.dotkernel.com/download/?did=34)
diff --git a/public/md-articles/dotkernel3/development-report-december-11-2017.md b/public/md-articles/dotkernel3/development-report-december-11-2017.md
index 914585e5..295b36a0 100644
--- a/public/md-articles/dotkernel3/development-report-december-11-2017.md
+++ b/public/md-articles/dotkernel3/development-report-december-11-2017.md
@@ -11,28 +11,23 @@ language: "en"
 # Development Report December 11, 2017
 
 ## TL;DR
+
 This report covers updates to the Dotkernel3 documentation: new release notes for the frontend and admin, a Webpack tutorial added to the Prerequisites section, and revisions to the Api Endpoint Documentation Guidelines.
 Contributor JapSeyz is thanked for this round of updates.
 
+## Documentation Updates
+
 This report contains updates about the Dotkernel3 documentation.
 
-We have added the release notes for Dotkernel3 **frontend** and **admin**: you can now check the Release Notes page.
+We have added the release notes for Dotkernel3 frontend and admin: you can now check the Release Notes page.
 
-Webpack tutorial has been added in the Prerequisites section.
+A Webpack tutorial has been added in the Prerequisites section.
 
 The Api Endpoint Documentation Guidelines were updated as well, a slightly different layout and some corrections were applied.
 
- 
-
-**Links**:
-
-- Release Notes page
-- Webpack tutorial
-- Api Endpoint Documentation Guidelines
-
- 
+## Contributors
 
-**Thanks to our contributors:**
+Thanks to our contributors:
 
 [JapSeyz](https://github.com/JapSeyz)
 
diff --git a/public/md-articles/dotkernel3/dotkernel-admin-v4.md b/public/md-articles/dotkernel3/dotkernel-admin-v4.md
index cbf13479..f86cbef6 100644
--- a/public/md-articles/dotkernel3/dotkernel-admin-v4.md
+++ b/public/md-articles/dotkernel3/dotkernel-admin-v4.md
@@ -11,14 +11,16 @@ language: "en"
 # Dotkernel Admin V4
 
 ## TL;DR
+
 Dotkernel Admin V4, officially released on 19 July 2022, is Dotkernel's PSR-7 Admin application built on Mezzio for managing and displaying tabular data from one or more databases.
 It supports PHP 8.1 (minimum PHP 7.4), offers a config-driven module/middleware/route setup, RBAC-based authorization guards, a Symfony Console-based CLI with a file locker, per-module routing via RoutesDelegator, and a Bootstrap 4.5.0 / Fontawesome 5.0.6 frontend using Bootstrap Table for data listing.
 
 ## Getting Started with Dotkernel Admin V4
 
-**[Dotkernel's PSR-7 Admin](https://github.com/dotkernel/admin)**  is an application based on **[Mezzio](https://getlaminas.org/)**, with the main purpose of managing and displaying tabular data from one or more databases components.
+Dotkernel's PSR-7 Admin is an application based on Mezzio, with the main purpose of managing and displaying tabular data from one or more databases components.
 
-On 19 July 2022 **Dotkernel Admin V4** has been officially released. **Dotkernel Admin V4** comes with various interesting features and overall improvement of the core framework.
+On 19 July 2022, Dotkernel Admin V4 has been officially released.
+Dotkernel Admin V4 comes with various interesting features and overall improvement of the core framework.
 
 ## Demo
 
@@ -26,29 +28,29 @@ Ready to try it out?
 
 There should be an admin account with the following credentials:
 
-- Username: **admin**
-- Password: **dotadmin**
+- Username: admin
+- Password: dotadmin
 
-Head over to [https://admin7.dotkernel.net/](https://admin7.dotkernel.net/) and see for yourself :)
+Head over to [https://admin7.dotkernel.net/](https://admin7.dotkernel.net/) and see for yourself.
 
 ## Dotkernel Admin V4 Features
 
 ### PHP 8.1
 
-**Dotkernel Admin V4** fully supports **PHP 8.1** with a minimum requirement of **PHP 7.4**.
+Dotkernel Admin V4 fully supports PHP 8.1 with a minimum requirement of PHP 7.4.
 
 ### Configurability
 
-From managing middleware order to simply adding an API key to you application the **config** directory is the way to go.
+From managing middleware order to simply adding an API key to your application, the config directory is the way to go.
 
-Want to register a new module? In `config.php` you will find the right place for it registering its `ConfigProvider.php`.
-Got a shiny new Middleware? You can put it with the rest of them in `pipeline.php` where you can even edit in which order they should run.
+Want to register a new module? In `config.php` you will find the right place for it, registering its `ConfigProvider.php`.
+Got a shiny new middleware? You can put it with the rest of them in `pipeline.php`, where you can even edit in which order they should run.
 
-You can further customize your app within the **autoload** directory by changing the application name and url into the `app.global.php`, adding the freshly created routes into `navigation.global.php` and much more.
+You can further customize your app within the autoload directory by changing the application name and URL in `app.global.php`, adding freshly created routes into `navigation.global.php`, and much more.
 
-Example adding a simple route to navigation bar:
+Example adding a simple route to the navigation bar:
 
-```
+```php
 [
     'options' => [
         'label' => 'Dashboard',
@@ -60,9 +62,9 @@ Example adding a simple route to navigation bar:
 ]
 ```
 
-or a group of 2 or more routes
+Or a group of 2 or more routes:
 
-```
+```php
 [
     'options' => [
         'label' => 'Manage admins',
@@ -90,11 +92,12 @@ or a group of 2 or more routes
 
 ### Authorization Guards
 
-The packages responsible for restricting access to certain parts of the application are [dot-rbac-guard](https://github.com/dotkernel/dot-rbac-guard) and [dot-rba](https://github.com/dotkernel/dot-rbac)[c](https://github.com/dotkernel/dot-rbac). These packages work together to create an infrastructure that is customizable and diversified to manage user access to the platform by specifying the type of role the user has.
+The packages responsible for restricting access to certain parts of the application are [dot-rbac-guard](https://github.com/dotkernel/dot-rbac-guard) and [dot-rbac](https://github.com/dotkernel/dot-rbac).
+These packages work together to create an infrastructure that is customizable and diversified to manage user access to the platform by specifying the type of role the user has.
 
 The `authorization.global.php` file provides multiple configurations specifying multiple roles as well as the types of permissions to which these roles have access.
 
-```
+```php
 //example of a flat RBAC model that specifies two types of roles as well as their permission
 'roles' => [
     'superuser' => [
@@ -114,15 +117,15 @@ The `authorization.global.php` file provides multiple configurations specifying
 ]
 ```
 
-The `authorization-guards.global.php` file provides configuration to restrict access to certain actions based on the permissions defined in `authorization.global.php` so basically we have to add the permissions in the dot-rbac configuration file first to specify the action restriction permissions.
+The `authorization-guards.global.php` file provides configuration to restrict access to certain actions based on the permissions defined in `authorization.global.php`, so basically the permissions have to be added in the dot-rbac configuration file first to specify the action restriction permissions.
 
-```
-//example of configuration example to restrict certain actions of some routes based on the permissions specified in the dot-rbac configuration file
+```php
+//example of configuration to restrict certain actions of some routes based on the permissions specified in the dot-rbac configuration file
 'rules' => [
     [
         'route' => 'account',
         'actions' => [
-            //list of actions to apply , or empty array for all actions
+            //list of actions to apply, or empty array for all actions
             'unregister',
             'avatar',
             'details',
@@ -147,25 +150,25 @@ The `authorization-guards.global.php` file provides configuration to restrict
 
 ### CLI
 
-For registering new command first make sure your command class extends `Symfony\Component\Console\Command\Command`, then you can enable the command by registering it in `config/autoload/cli.global.php`.
+For registering a new command, first make sure your command class extends `Symfony\Component\Console\Command\Command`, then you can enable the command by registering it in `config/autoload/cli.global.php`.
 
-Here you will also find our brand new file locker configuration so you can easily turn in on or off ( by default: `'enabled' => true` )
+Here you will also find the brand new file locker configuration, so you can easily turn it on or off (by default: `'enabled' => true`).
 
-Note: The **File Locker System** will create a `command-{command-default-name}.lock` file which will not let another instance of the same command to run until the previous one has finished.
+Note: the File Locker System will create a `command-{command-default-name}.lock` file which will not let another instance of the same command run until the previous one has finished.
 
-You can list the existing commands running the following in a terminal:
+You can list the existing commands by running the following in a terminal:
 
-```
+```bash
 php /bin/cli.php list
 ```
 
-Note: You can take as example `Dot\Cli\Command\DemoCommand`
+Note: you can take as example `Dot\Cli\Command\DemoCommand`.
 
 ### Routing
 
-Providing each Module with a `RoutesDelegator.php` file for managing existing routes inside that specific module and an easy way of adding new ones providing the route path, Middleware that the route will use, an array of accepted methods and the route name.
+Each module gets a `RoutesDelegator.php` file for managing existing routes inside that specific module, providing an easy way of adding new ones by specifying the route path, the middleware that the route will use, an array of accepted methods, and the route name.
 
-```
+```php
 $app->route(
     '/admin[/{action}[/{uuid}]]',
     AdminController::class,
@@ -177,19 +180,19 @@ $app->route(
  );
 ```
 
-Note: The optional attributes on the route path are marked between **[]** like 
+Note: the optional attributes on the route path are marked between `[]`.
 
 ### Frontend
 
-As for the frontend toolkit we chose to use **Bootstrap** **4.5.0** in combination with **Fontawesome 5.0.6** for a minimalist but efficient design.
+As for the frontend toolkit, we chose to use Bootstrap 4.5.0 in combination with Fontawesome 5.0.6 for a minimalist but efficient design.
 
-For assembling the `app.js` and `app.css` along with handling packages from `package.json` we recommend using **npm 7** or up.
+For assembling `app.js` and `app.css` along with handling packages from `package.json`, we recommend using npm 7 or up.
 
-Our choice for listing raw data was **[Bootstrap Table](https://bootstrap-table.com/)** because it is easy to implement and configurable in many ways.
+Our choice for listing raw data was Bootstrap Table because it is easy to implement and configurable in many ways.
 
-Lets take admin table as an example:
+Let's take the admin table as an example:
 
-```
+```html
 <table data-toggle="table" data-url="/admin/list" data-click-to-select="true"
        data-mobile-responsive="true" data-min-width="800"
        data-check-on-init="true" data-id-field="uuid"
@@ -213,9 +216,9 @@ Lets take admin table as an example:
 </table>
 ```
 
-Here we can tweak directly into the table data how our table looks, arrange in page or a couple of usages like the api url for pulling data, pagination, allowing multiple row select and more...
+Here we can tweak directly in the table data how our table looks, arrange the page, and use a couple of other features like the API URL for pulling data, pagination, allowing multiple row selection, and more.
 
-Note: You`ll find in the `#tableToolbar` buttons that toggle a **modal** for adding/editing/deleting admins.
+Note: you'll find in the `#tableToolbar` buttons that toggle a modal for adding/editing/deleting admins.
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel3/dotkernel-admin-version-3-launched.md b/public/md-articles/dotkernel3/dotkernel-admin-version-3-launched.md
index a021c4e4..73facea6 100644
--- a/public/md-articles/dotkernel3/dotkernel-admin-version-3-launched.md
+++ b/public/md-articles/dotkernel3/dotkernel-admin-version-3-launched.md
@@ -11,36 +11,28 @@ language: "en"
 # Dotkernel Admin version 3 launched
 
 ## TL;DR
+
 Dotkernel Admin version 3 has launched as a basic admin panel built on Bootstrap ^4.5.0 and Doctrine, performing CRUD operations over a database on top of the Mezzio microframework and Laminas components.
 The source is available on GitHub, with a live demo running at admin7.dotkernel.net.
 Branch 3.0 is now the default branch, requiring Mezzio ^3.2, PHP ^7.4, Doctrine 2.7.x, Twig 3.x, and Bootstrap 4.5, with dot-* packages limited to version 3.x and above.
 
-## Dotkernel Admin PHP Application version 3 was launched.
-
-[![](https://img.shields.io/github/issues/dotkernel/admin)](https://github.com/dotkernel/frontend/issues)[![](https://img.shields.io/github/stars/dotkernel/admin)](https://github.com/dotkernel/admin)![](https://img.shields.io/packagist/php-v/dotkernel/admin/3.0.0)![](https://img.shields.io/packagist/v/dotkernel/admin) [![](https://img.shields.io/github/license/dotkernel/frontend)](https://github.com/dotkernel/admin/blob/3.0/LICENSE.md)
-
-Dotkernel is a Collection of PSR-7 Middleware applications built on top of [Mezzio microframework and using Laminas components](https://getlaminas.org/)
-
- Dotkernel Admin is a basic admin panel, based on Boostrap ^4.5.0 , using Doctrine and performing basic CRUD operations over a database.
-
-You can **clone** it from [github](https://github.com/dotkernel/admin)
-
-**Live demo:** [admin7.dotkernel.net](https://admin7.dotkernel.net)
-
-### Changelog:
+## Dotkernel Admin PHP Application Version 3 Was Launched
 
-*Branch 3.0 is the current and default branch* , and :
+Dotkernel is a collection of PSR-7 Middleware applications built on top of the [Mezzio microframework and using Laminas components](https://getlaminas.org/).
+Dotkernel Admin is a basic admin panel, based on Bootstrap ^4.5.0, using Doctrine and performing basic CRUD operations over a database.
+You can clone it from [GitHub](https://github.com/dotkernel/admin).
+Live demo: [admin7.dotkernel.net](https://admin7.dotkernel.net)
 
-- Require **Mezzio** **^3.2**
-- Require **PHP ^7.4**
-- Require **Doctrine 2.7.x**
-- Require **Twig 3.x**
-- Require **Bootstrap** 4.5
-- Limited dot-* packages to version **3.x** and above
+### Changelog
 
- 
+Branch 3.0 is the current and default branch, and:
 
- 
+- Require Mezzio ^3.2
+- Require PHP ^7.4
+- Require Doctrine 2.7.x
+- Require Twig 3.x
+- Require Bootstrap 4.5
+- Limited dot-* packages to version 3.x and above
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel3/dotkernel-api-architecture-and-components.md b/public/md-articles/dotkernel3/dotkernel-api-architecture-and-components.md
index 472ac86d..32b7eced 100644
--- a/public/md-articles/dotkernel3/dotkernel-api-architecture-and-components.md
+++ b/public/md-articles/dotkernel3/dotkernel-api-architecture-and-components.md
@@ -11,91 +11,47 @@ language: "en"
 # Dotkernel API: architecture and components
 
 ## TL;DR
+
 Dotkernel API is built on the Mezzio microframework and Laminas components, based on Enrico Zimuel's Zend Expressive API skeleton and implementing PSR-3, PSR-4, PSR-7, PSR-11, and PSR-15.
 Its core components include Doctrine ORM for persistence, mezzio-hal for API payloads, mezzio-cors for CORS handling, and mezzio-authentication-oauth2 for OAuth 2.0 authentication, alongside Postman-based documentation, configurable routing and commands, a file locker system, and a factory-made test suite.
 
 > This article refers to Dotkernel API v5. Checkout out the new additions for [Dotkernel API v6](https://www.dotkernel.com/headless-platform/dotkernel-api-v6-the-root-of-dotkernel-headless-platform/) to stay up-to-date.
 
-Based on Enrico Zimuel's [Zend Expressive API - Skeleton example](https://github.com/ezimuel/zend-expressive-api), Dotkernel API runs on [Mezzio](https://github.com/mezzio) microframework   and[Laminas](https://github.com/laminas) components and implements standards like PSR-3, PSR-4, PSR-7, PSR-11 and PSR-15.
-
+Based on Enrico Zimuel's [Zend Expressive API - Skeleton example](https://github.com/ezimuel/zend-expressive-api), Dotkernel API runs on [Mezzio](https://github.com/mezzio) microframework and [Laminas](https://github.com/laminas) components and implements standards like PSR-3, PSR-4, PSR-7, PSR-11 and PSR-15.
 Here is a list of the core components:
 
-- 
-
-- 
-  - Mezzio Microframework ([mezzio/mezzio](https://github.com/mezzio/mezzio))
-
-- 
-  - Error Handler ([dotkernel/dot-errorhandler](https://packagist.org/packages/dotkernel/dot-errorhandler))
-
-- 
-  - Problem Details ([mezzio/mezzio-problem-details](https://docs.mezzio.dev/mezzio-problem-details/))
-
-- 
-  - CORS ([mezzio/mezzio-cors](https://docs.mezzio.dev/mezzio-cors/))
-
-- 
-  - Routing ([mezzio/mezzio-fastroute](https://github.com/mezzio/mezzio-fastroute))
-
-- 
-  - Authentication ([mezzio/mezzio-authentication](https://docs.mezzio.dev/mezzio-authentication/))
-
-- 
-  - Authorization ([mezzio/mezzio-authorization](https://docs.mezzio.dev/mezzio-authorization/))
-
-- 
-  - Config Aggregator ([laminas/laminas-config-aggregator](https://github.com/laminas/laminas-config-aggregator))
-
-- 
-  - Container ([roave/psr-container-doctrine](https://github.com/Roave/psr-container-doctrine))
-
-- 
-  - Annotations ([dotkernel/dot-annotated-services](https://packagist.org/packages/dotkernel/dot-annotated-services))
-
-- 
-  - Input Filter ([laminas/laminas-inputfilter](https://github.com/laminas/laminas-inputfilter))
-
-- 
-  - Doctrine  2 ORM ([doctrine/orm](https://github.com/doctrine/orm))
-
-- 
-  - Hydrator ([laminas/laminas-hydrator](https://github.com/laminas/laminas-hydrator))
-
-- 
-  - Paginator ([laminas/laminas-paginator](https://github.com/laminas/laminas-paginator))
-
-- 
-  - HAL ([mezzio/mezzio-hal](https://docs.mezzio.dev/mezzio-hal/))
-
-- 
-  - CLI ([dotkernel/dot-cli](https://packagist.org/packages/dotkernel/dot-cli))
-
-- 
-  - TwigRenderer ([mezzio/mezzio-twigrenderer](https://github.com/mezzio/mezzio-twigrenderer))
-
-- 
-  - Fixtures ([dotkernel/dot-data-fixtures](https://packagist.org/packages/dotkernel/dot-data-fixtures))
-
-- 
-  - UUID ([ramsey/uuid-doctrine](https://github.com/mezzio/mezzio-twigrenderer))
+- Mezzio Microframework ([mezzio/mezzio](https://github.com/mezzio/mezzio))
+- Error Handler ([dotkernel/dot-errorhandler](https://packagist.org/packages/dotkernel/dot-errorhandler))
+- Problem Details ([mezzio/mezzio-problem-details](https://docs.mezzio.dev/mezzio-problem-details/))
+- CORS ([mezzio/mezzio-cors](https://docs.mezzio.dev/mezzio-cors/))
+- Routing ([mezzio/mezzio-fastroute](https://github.com/mezzio/mezzio-fastroute))
+- Authentication ([mezzio/mezzio-authentication](https://docs.mezzio.dev/mezzio-authentication/))
+- Authorization ([mezzio/mezzio-authorization](https://docs.mezzio.dev/mezzio-authorization/))
+- Config Aggregator ([laminas/laminas-config-aggregator](https://github.com/laminas/laminas-config-aggregator))
+- Container ([roave/psr-container-doctrine](https://github.com/Roave/psr-container-doctrine))
+- Annotations ([dotkernel/dot-annotated-services](https://packagist.org/packages/dotkernel/dot-annotated-services))
+- Input Filter ([laminas/laminas-inputfilter](https://github.com/laminas/laminas-inputfilter))
+- Doctrine 2 ORM ([doctrine/orm](https://github.com/doctrine/orm))
+- Hydrator ([laminas/laminas-hydrator](https://github.com/laminas/laminas-hydrator))
+- Paginator ([laminas/laminas-paginator](https://github.com/laminas/laminas-paginator))
+- HAL ([mezzio/mezzio-hal](https://docs.mezzio.dev/mezzio-hal/))
+- CLI ([dotkernel/dot-cli](https://packagist.org/packages/dotkernel/dot-cli))
+- TwigRenderer ([mezzio/mezzio-twigrenderer](https://github.com/mezzio/mezzio-twigrenderer))
+- Fixtures ([dotkernel/dot-data-fixtures](https://packagist.org/packages/dotkernel/dot-data-fixtures))
+- UUID ([ramsey/uuid-doctrine](https://github.com/mezzio/mezzio-twigrenderer))
 
 ## Doctrine 2 ORM
 
 For the persistence in a relational database management system we chose [Doctrine ORM](https://www.doctrine-project.org/projects/doctrine-orm/en/2.14/index.html) (object-relational mapper).
-
 The benefit of Doctrine for the programmer is the ability to focus on the object-oriented business logic and worry about persistence only as a secondary priority.
 
 ## Documentation
 
-Our documentation is [Postman](https://www.postman.com/) based. We use the following files in which we store information about every available endpoint ready to be tested:
+Our documentation is [Postman](https://www.postman.com/) based.
+We use the following files in which we store information about every available endpoint ready to be tested:
 
-- 
-
-- 
-  - `documentation/Dotkernel_API.postman_collection.json`
-
-- 
-  - `documentation/Dotkernel_API.postman_environment.json`
+- `documentation/Dotkernel_API.postman_collection.json`
+- `documentation/Dotkernel_API.postman_environment.json`
 
 ## Hypertext Application Language
 
@@ -103,64 +59,57 @@ For our API payloads (a value object for describing the API resource, its relati
 
 ## CORS
 
-By using `MezzioCorsMiddlewareCorsMiddleware`, the **CORS preflight** will be recognized and the middleware will start to detect the proper **CORS configuration**. The **Router** is used to detect every allowed request method by executing a route match with all possible request methods. Therefore, for every preflight request, there is at least one Router request.
+By using `MezzioCorsMiddlewareCorsMiddleware`, the CORS preflight will be recognized and the middleware will start to detect the proper CORS configuration.
+The Router is used to detect every allowed request method by executing a route match with all possible request methods.
+Therefore, for every preflight request, there is at least one Router request.
 
 ## OAuth 2.0
 
-OAuth 2.0 is an authorization framework that enables applications to obtain limited access to user accounts on your **Dotkernel API**. We are using [mezzio/mezzio-authentication-oauth2](https://docs.mezzio.dev/mezzio-authentication-oauth2/) which provides **OAuth 2.0** authentication for Mezzio and PSR-7/PSR-15 applications by using [league/oauth2-server](https://oauth2.thephpleague.com/) package.
+OAuth 2.0 is an authorization framework that enables applications to obtain limited access to user accounts on your Dotkernel API.
+We are using [mezzio/mezzio-authentication-oauth2](https://docs.mezzio.dev/mezzio-authentication-oauth2/) which provides OAuth 2.0 authentication for Mezzio and PSR-7/PSR-15 applications by using the [league/oauth2-server](https://oauth2.thephpleague.com/) package.
 
 ## Email
 
-It is not unlikely for an API to send emails depending on the use case. Here is another area where **Dotkernel API** shines. Using `DotMailServiceMailService` provided by [dotkernel/dot-mail](https://packagist.org/packages/dotkernel/dot-mail) you can easily send custom email templates.
+It is not unlikely for an API to send emails depending on the use case.
+Here is another area where Dotkernel API shines.
+Using `DotMailServiceMailService` provided by [dotkernel/dot-mail](https://packagist.org/packages/dotkernel/dot-mail) you can easily send custom email templates.
 
 ## Configuration
 
-From authorization at request route level to API keys for your application, you can find every configuration variable in the **config** directory.
-
-**Registering** a **new module** can be done by including its `ConfigProvider.php` in `config.php`.
-
-Brand new **middleware**s should go into `pipeline.php`. Here you can edit the order in which they run and find more info about the currently included ones.
-
-You can further customize your api within the **autoload** directory where each configuration category has its own file.
+From authorization at request route level to API keys for your application, you can find every configuration variable in the config directory.
+Registering a new module can be done by including its `ConfigProvider.php` in `config.php`.
+Brand new middlewares should go into `pipeline.php`.
+Here you can edit the order in which they run and find more info about the currently included ones.
+You can further customize your API within the autoload directory where each configuration category has its own file.
 
 ## Routing
 
-Each module has a `RoutesDelegator.php` file for managing existing routes inside that specific module. It also allows an quick way of adding new routes by providing the route path, Middlewares that the route will use and the route name.
-
-You can allocate **permissions** per **route name** in order to restrict access for a user role to a specific route in `config/autoload/authorization.global.php`.
+Each module has a `RoutesDelegator.php` file for managing existing routes inside that specific module.
+It also allows a quick way of adding new routes by providing the route path, Middlewares that the route will use and the route name.
+You can allocate permissions per route name in order to restrict access for a user role to a specific route in `config/autoload/authorization.global.php`.
 
 ## Commands
 
-For registering new commands first make sure your command class extends `SymfonyComponentConsoleCommandCommand`. Then you can enable it by registering it in `config/autoload/cli.global.php`.
+For registering new commands first make sure your command class extends `SymfonyComponentConsoleCommandCommand`.
+Then you can enable it by registering it in `config/autoload/cli.global.php`.
 
-## File locker
+## File Locker
 
-Here you will also find our brand new **file locker** configuration so you can easily turn it on or off ( by default: `'enabled' => true` )
-
-Note: The **File Locker System** will create a `command-{command-default-name}.lock` file which will not let another instance of the same command to run until the previous one has finished.
+Here you will also find our brand new file locker configuration so you can easily turn it on or off (by default: `'enabled' => true`).
+Note: The File Locker System will create a `command-{command-default-name}.lock` file which will not let another instance of the same command run until the previous one has finished.
 
 ## PSR Standards
 
-- 
-
-- 
-  - [PSR-3: Logger Interface](https://www.php-fig.org/psr/psr-3/) - the application uses `LoggerInterface` for error logging
-
-- 
-  - [PSR-4: Autoloader](https://www.php-fig.org/psr/psr-4/) - the application locates classes using an autoloader
-
-- 
-  - [PSR-7: HTTP message interfaces](https://www.php-fig.org/psr/psr-7/) - the handlers return `ResponseInterface`
-
-- 
-  - [PSR-11: Container interface](https://www.php-fig.org/psr/psr-11/) - the application is container-based
-
-- 
-  - [PSR-15: HTTP Server Request Handlers](https://www.php-fig.org/psr/psr-15/) - the handlers implement `RequestHandlerInterface`
+- [PSR-3: Logger Interface](https://www.php-fig.org/psr/psr-3/) - the application uses `LoggerInterface` for error logging
+- [PSR-4: Autoloader](https://www.php-fig.org/psr/psr-4/) - the application locates classes using an autoloader
+- [PSR-7: HTTP message interfaces](https://www.php-fig.org/psr/psr-7/) - the handlers return `ResponseInterface`
+- [PSR-11: Container interface](https://www.php-fig.org/psr/psr-11/) - the application is container-based
+- [PSR-15: HTTP Server Request Handlers](https://www.php-fig.org/psr/psr-15/) - the handlers implement `RequestHandlerInterface`
 
 ## Tests
 
-One of the best ways to ensure the quality of your product is to create and run functional and unit tests. You can find factory-made tests in the `tests/AppTest/` folder, and you can also register your own.
+One of the best ways to ensure the quality of your product is to create and run functional and unit tests.
+You can find factory-made tests in the `tests/AppTest/` folder, and you can also register your own.
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel3/dotkernel-frontend-version-3-launched.md b/public/md-articles/dotkernel3/dotkernel-frontend-version-3-launched.md
index 893d8595..2ff64334 100644
--- a/public/md-articles/dotkernel3/dotkernel-frontend-version-3-launched.md
+++ b/public/md-articles/dotkernel3/dotkernel-frontend-version-3-launched.md
@@ -11,33 +11,26 @@ language: "en"
 # Dotkernel Frontend version 3 launched
 
 ## TL;DR
+
 Dotkernel Frontend version 3 has launched as part of the Dotkernel collection of PSR-7 Middleware applications, built on the Mezzio microframework using Laminas components.
 The source is available on GitHub, with a live demo running at v3.dotkernel.net.
 Branch 3.0 is now the default branch, requiring Mezzio ^3.2, PHP ^7.4, Doctrine 2.7.x, and Twig 3.x, with dot-* packages limited to version 3.x and above.
 
-## Dotkernel Frontend PHP Application version 3 was launched.
-
-[![](https://img.shields.io/github/issues/dotkernel/frontend)](https://github.com/dotkernel/frontend/issues) [![](https://img.shields.io/github/stars/dotkernel/frontend)](https://github.com/dotkernel/frontend) ![](https://img.shields.io/packagist/php-v/dotkernel/frontend/3.0.0)![](https://img.shields.io/packagist/v/dotkernel/frontend) [![](https://img.shields.io/github/license/dotkernel/frontend)](https://github.com/dotkernel/frontend/blob/3.0/LICENSE.md)
-
-Dotkernel is a Collection of PSR-7 Middleware applications built on top of [Mezzio microframework and using Laminas components](https://getlaminas.org/)
-
-You can **clone** it from [github](https://github.com/dotkernel/frontend)
-
-**Live demo:** [v3.dotkernel.net](https://v3.dotkernel.net)
-
-### Changelog:
+## Dotkernel Frontend PHP Application Version 3 Was Launched
 
-*Branch 3.0 is the current and default branch* , and :
+Dotkernel is a collection of PSR-7 Middleware applications built on top of the [Mezzio microframework and using Laminas components](https://getlaminas.org/).
+You can clone it from [GitHub](https://github.com/dotkernel/frontend).
+Live demo: [v3.dotkernel.net](https://v3.dotkernel.net)
 
-- Require **Mezzio** **^3.2**
-- Require **PHP ^7.4**
-- Require **Doctrine 2.7.x**
-- Require **Twig 3.x**
-- Limited dot-* packages to version **3.x** and above
+### Changelog
 
- 
+Branch 3.0 is the current and default branch, and:
 
- 
+- Require Mezzio ^3.2
+- Require PHP ^7.4
+- Require Doctrine 2.7.x
+- Require Twig 3.x
+- Limited dot-* packages to version 3.x and above
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel3/dotkernel3-stable-release-version-1-0.md b/public/md-articles/dotkernel3/dotkernel3-stable-release-version-1-0.md
index ab6f8cf9..3066d6fd 100644
--- a/public/md-articles/dotkernel3/dotkernel3-stable-release-version-1-0.md
+++ b/public/md-articles/dotkernel3/dotkernel3-stable-release-version-1-0.md
@@ -11,35 +11,36 @@ language: "en"
 # Dotkernel3 - Stable Release version 1.0
 
 ## TL;DR
+
 Dotkernel3 1.0 updates the core packages to support Zend Expressive 3 and PSR-15 middleware, making both frontend (1.0.0) and admin (1.0.1) easier to migrate.
 No functional changes were made to the core code, though projects using the old http-interop/http-middleware package must migrate to the psr/http-server-middleware interfaces.
 Existing Dotkernel 3 (Expressive 2) projects can follow a separate guide to move to Zend Expressive 3.
 
-Dotkernel was updated to support **[Zend Expressive 3](https://docs.zendframework.com/zend-expressive/) **alongside with **PSR-15 **middleware.
+## Release Overview
+
+Dotkernel was updated to support Zend Expressive 3 alongside PSR-15 middleware.
 
-We have updated the core packages to support **[PSR-15 Middleware](https://www.php-fig.org/psr/psr-15/).**
+We have updated the core packages to support PSR-15 Middleware.
 
-By updating the core packages both frontend and admin are easier to migrate.
+By updating the core packages, both frontend and admin are easier to migrate.
 
-The new versions are: frontend -> [1.0.0](https://packagist.org/packages/dotkernel/frontend#v1.0.0) admin -> [1.0.1](https://packagist.org/packages/dotkernel/admin#v1.0.1)
+The new versions are:
+frontend -> 1.0.0
+admin -> 1.0.1
 
-If your project is a Dotkernel 3 instance (based on expressive 2), you can migrate your project to Zend Expressive 3 by following [this guide](https://www.dotkernel.com/how-to/migrating-dotkernel-3-from-zend-expressive-2-to-zend-expressive-3/).
+If your project is a Dotkernel 3 instance (based on Expressive 2), you can migrate your project to Zend Expressive 3 by following this guide.
 
-## What's new
+## What's New
 
 - Runs on Zend Stratigility / Zend Expressive 3.0
 - Middleware is now PSR-15 compliant
 - PHP >=7.1 Support
 
- 
-
 ## Changes
 
 - No functional changes were made in the core code
-- If your middleware code is based on the **dotkernel**/**dot-controller** package no middleware migration is needed
-- If your middleware code is based on the **http-interop/http-middleware** migration must be made to implement interfaces in **psr/http-server-middleware**
-
- 
+- If your middleware code is based on the dotkernel/dot-controller package, no middleware migration is needed
+- If your middleware code is based on the http-interop/http-middleware, migration must be made to implement interfaces in psr/http-server-middleware
 
 ## Packages Updated
 
@@ -65,7 +66,7 @@ If your project is a Dotkernel 3 instance (based on expressive 2), you can migra
 - dotkernel/dot-twigrenderer:^1.1
 - dotkernel/dot-user:^1.0
 
-## Zend Packages (support) Updated
+## Zend Packages (Support) Updated
 
 - psr/http-server-middleware:^1.0
 - psr/http-server-handler:^1.0
@@ -79,8 +80,6 @@ If your project is a Dotkernel 3 instance (based on expressive 2), you can migra
 - zendframework/zend-stratigility:^3.0
 - zendframework/zend-component-installer:^2.0
 
- 
-
 ## Packages Removed
 
 - http-interop/http-middleware
diff --git a/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-admin.md b/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-admin.md
index 54e31efc..3101ec0e 100644
--- a/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-admin.md
+++ b/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-admin.md
@@ -11,75 +11,75 @@ language: "en"
 # PHP 8.3 support in Dotkernel Admin
 
 ## TL;DR
+
 Dotkernel Admin added PHP 8.3 support in release 4.3.1, dropping PHP 8.1 and now supporting only PHP 8.2 and PHP 8.3.
 The update brought numerous dependency bumps across dotkernel/*, laminas/*, and mezzio/* packages, removed PhpFileCache-related cache configuration because doctrine/cache dropped its implementation classes, and removed doctrine/doctrine-module due to a conflict, which may affect packages that depended on it.
 The `AdminService::logAdminVisit` method was also updated to no longer return `AddressNotFoundException`.
 
-With the release of **PHP 8.3**, the Dotkernel team has been working on updating the dependencies in our packages. Eventually, this allowed us to update our Applications as well, starting with the [Admin](https://github.com/dotkernel/admin), in release **4.3.1**
-
+With the release of PHP 8.3, the Dotkernel team has been working on updating the dependencies in our packages.
+Eventually, this allowed us to update our applications as well, starting with the [Admin](https://github.com/dotkernel/admin), in release 4.3.1.
 There were some issues and backward incompatibilities that we will list below.
-
 The full list of file changes is [here](https://github.com/dotkernel/admin/pull/218/files).
 
-- **Supports only PHP 8.2 and PHP 8.3**
+- Supports only PHP 8.2 and PHP 8.3
   - Removed support for PHP 8.1
   - Updated workflows - removed PHP 8.1
-  - Commits [#1](https://github.com/dotkernel/admin/commit/12d46e671ea430d93e4f4a38ba10e74d375ca944) and [#](https://github.com/dotkernel/admin/commit/5233c9dabe5264553956df29a66ddfd5808a283b)[2](https://github.com/dotkernel/admin/commit/5233c9dabe5264553956df29a66ddfd5808a283b)
-- **Updated** dependencies
-  - **require**
-    - "dotkernel/dot-cli": "^3.4.2",
-    - "dotkernel/dot-controller": "^3.4.3",
-    - "dotkernel/dot-data-fixtures": "^1.1.3",
-    - "dotkernel/dot-errorhandler": "^3.3.2",
-    - "dotkernel/dot-flashmessenger": "^3.4.2",
-    - "dotkernel/dot-geoip": "^3.5.3",
-    - "dotkernel/dot-helpers": "^3.4.2",
-    - "dotkernel/dot-mail": "^4.1.1",
-    - "dotkernel/dot-navigation": "^3.4.2",
-    - "dotkernel/dot-rbac-guard": "^3.4.2",
-    - "dotkernel/dot-session": "^5.4.2",
-    - "dotkernel/dot-twigrenderer": "3.4.3",
-    - "dotkernel/dot-user-agent-sniffer": "^3.3.3",
-    - "friendsofphp/proxy-manager-lts": "^1.0.16",
-    - "laminas/laminas-component-installer": "^3.4.0",
-    - "laminas/laminas-config-aggregator": "^1.14.0",
-    - "laminas/laminas-i18n": "^2.26.0",
-    - "laminas/laminas-math": "^3.7.0",
-    - "mezzio/mezzio": "^3.18.0",
-    - "mezzio/mezzio-authorization-rbac": "^1.7.0",
-    - "mezzio/mezzio-cors": "^1.11.1",
-    - "mezzio/mezzio-fastroute": "^3.11.0",
-    - "ramsey/uuid-doctrine": "^2.0.0",
-    - "roave/psr-container-doctrine": "^4.1.0"
-  - **require-dev**
-    - "filp/whoops": "^2.15.4",
-    - "laminas/laminas-development-mode": "^3.12.0",
-    - "laminas/laminas-http": "^2.19.0",
-    - "mezzio/mezzio-tooling": "^2.9.0",
-    - "phpunit/phpunit": "^10.5.9",
-    - "vimeo/psalm": "^5.20.0"
+  - Commits [#1](https://github.com/dotkernel/admin/commit/12d46e671ea430d93e4f4a38ba10e74d375ca944) and [#2](https://github.com/dotkernel/admin/commit/5233c9dabe5264553956df29a66ddfd5808a283b)
+- Updated dependencies
+  - require
+    - `"dotkernel/dot-cli": "^3.4.2"`
+    - `"dotkernel/dot-controller": "^3.4.3"`
+    - `"dotkernel/dot-data-fixtures": "^1.1.3"`
+    - `"dotkernel/dot-errorhandler": "^3.3.2"`
+    - `"dotkernel/dot-flashmessenger": "^3.4.2"`
+    - `"dotkernel/dot-geoip": "^3.5.3"`
+    - `"dotkernel/dot-helpers": "^3.4.2"`
+    - `"dotkernel/dot-mail": "^4.1.1"`
+    - `"dotkernel/dot-navigation": "^3.4.2"`
+    - `"dotkernel/dot-rbac-guard": "^3.4.2"`
+    - `"dotkernel/dot-session": "^5.4.2"`
+    - `"dotkernel/dot-twigrenderer": "3.4.3"`
+    - `"dotkernel/dot-user-agent-sniffer": "^3.3.3"`
+    - `"friendsofphp/proxy-manager-lts": "^1.0.16"`
+    - `"laminas/laminas-component-installer": "^3.4.0"`
+    - `"laminas/laminas-config-aggregator": "^1.14.0"`
+    - `"laminas/laminas-i18n": "^2.26.0"`
+    - `"laminas/laminas-math": "^3.7.0"`
+    - `"mezzio/mezzio": "^3.18.0"`
+    - `"mezzio/mezzio-authorization-rbac": "^1.7.0"`
+    - `"mezzio/mezzio-cors": "^1.11.1"`
+    - `"mezzio/mezzio-fastroute": "^3.11.0"`
+    - `"ramsey/uuid-doctrine": "^2.0.0"`
+    - `"roave/psr-container-doctrine": "^4.1.0"`
+  - require-dev
+    - `"filp/whoops": "^2.15.4"`
+    - `"laminas/laminas-development-mode": "^3.12.0"`
+    - `"laminas/laminas-http": "^2.19.0"`
+    - `"mezzio/mezzio-tooling": "^2.9.0"`
+    - `"phpunit/phpunit": "^10.5.9"`
+    - `"vimeo/psalm": "^5.20.0"`
   - Commit [#1](https://github.com/dotkernel/admin/commit/a4cfb4f8873e18e100ed089a7ccfed0b3e8603fc)
-- **Added** *"laminas/laminas-http": "^2.19.0"* to composer.json *require-dev* (required for tests)
-  - Commit[#1](https://github.com/dotkernel/admin/commit/b47119e7cbd1c96648cac2d1781fb227f3c12cc9)
-- **Updated** *src/Admin/src/Service/AdminService.php*, function *logAdminVisit*
-  - Note: No longer returns *AddressNotFoundException*
-  - Commit[#](https://github.com/dotkernel/admin/commit/b47119e7cbd1c96648cac2d1781fb227f3c12cc9)[1](https://github.com/dotkernel/admin/commit/b47119e7cbd1c96648cac2d1781fb227f3c12cc9)
-- **Removed** parameter from configuration files and uses for class *PhpFileCache* (required by cache)
-  - Removed *use Doctrine\Common\Cache\PhpFileCache;* from from local.php.dist (local.php) and doctrine.global.php
-  - Removed the parameters used by cache *configuration* from local.php.dist (local.php) and *cache* from doctrine.global.php
-  - Commit [#1](https://github.com/dotkernel/admin/commit/73c79dd707e8575adec013ae1cd85f87c01787f1) and [#2](https://github.com/dotkernel/admin/commit/6585a39c0077763e55161b8749f19ac2a846f5df)
-- **Updated** *dotkernel/dot-twigrenderer* dependencies
-  - Removed *doctrine/doctrine-module* because of conflict
-  - Other packages that don’t get installed because of removing *doctrine/doctrine-module -* make sure to check if their functionality is used in your project
-    - doctrine/doctrine-laminas-hydrator
-    - laminas/laminas-cache-storage-adapter-filesystem
-    - laminas/laminas-cache-storage-adapter-memory
-    - laminas/laminas-mvc
-    - laminas/laminas-paginator
-
-Updating to **PHP 8.3** has not been as streamlined as in previous updates, but the advantages of doing so outweigh the extra work on the custom code to remove potential incompatibilities.
+- Added `"laminas/laminas-http": "^2.19.0"` to composer.json require-dev (required for tests)
+  - Commit [#1](https://github.com/dotkernel/admin/commit/b47119e7cbd1c96648cac2d1781fb227f3c12cc9)
+- Updated `src/Admin/src/Service/AdminService.php`, function `logAdminVisit`
+  - Note: No longer returns `AddressNotFoundException`
+  - Commit [#1](https://github.com/dotkernel/admin/commit/b47119e7cbd1c96648cac2d1781fb227f3c12cc9)
+- Removed parameter from configuration files and uses for class `PhpFileCache` (required by cache)
+  - Removed `use Doctrine\Common\Cache\PhpFileCache;` from local.php.dist (local.php) and doctrine.global.php
+  - Removed the parameters used by cache configuration from local.php.dist (local.php) and cache from doctrine.global.php
+  - Commits [#1](https://github.com/dotkernel/admin/commit/73c79dd707e8575adec013ae1cd85f87c01787f1) and [#2](https://github.com/dotkernel/admin/commit/6585a39c0077763e55161b8749f19ac2a846f5df)
+- Updated `dotkernel/dot-twigrenderer` dependencies
+  - Removed `doctrine/doctrine-module` because of conflict
+  - Other packages that don't get installed because of removing `doctrine/doctrine-module` - make sure to check if their functionality is used in your project
+    - `doctrine/doctrine-laminas-hydrator`
+    - `laminas/laminas-cache-storage-adapter-filesystem`
+    - `laminas/laminas-cache-storage-adapter-memory`
+    - `laminas/laminas-mvc`
+    - `laminas/laminas-paginator`
 
-The Dotkernel team is focused on the cache that has been removed in the current version because *doctrine/cache* deleted their cache implementation classes. We are also updating our existing projects to PHP 8.3 and testing the changes on live environments to iron out any other issues.
+Updating to PHP 8.3 has not been as streamlined as in previous updates, but the advantages of doing so outweigh the extra work on the custom code to remove potential incompatibilities.
+The Dotkernel team is focused on the cache that has been removed in the current version because `doctrine/cache` deleted their cache implementation classes.
+We are also updating our existing projects to PHP 8.3 and testing the changes on live environments to iron out any other issues.
 
 ## FAQ
 
diff --git a/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-api.md b/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-api.md
index 2b43fa53..fc391751 100644
--- a/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-api.md
+++ b/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-api.md
@@ -11,80 +11,89 @@ language: "en"
 # PHP 8.3 support in Dotkernel API
 
 ## TL;DR
+
 Dotkernel API, now at v4.2.1, is the last remaining Dotkernel application updated to support PHP 8.3, following the same approach used for the Frontend update.
 The update drops PHP 8.1 support, updates a large set of dependencies, removes the `PhpFileCache`-based configuration in favor of the new `dot-cache` package, and requires a small query change (`useQueryCache()` to `setCacheable()`).
 
-The last remaining application to be updated to support PHP 8.3 is the [API](https://github.com/dotkernel/api), now at v4.2.1. The steps taken to perform the update are similar to the ones in the update for the [Frontend](https://github.com/dotkernel/frontend).
-
-The full list of file changes is [here](https://github.com/dotkernel/api/pull/222).
-
-- **Supports only PHP 8.2 and PHP 8.3**
-  - Removed support for PHP 8.1
-  - Updated workflows - removed PHP 8.1
-  - Commit [#1](https://github.com/dotkernel/api/commit/53d95c5e04eacc339d4ba87d7f94ce3b042e819d)
-- **Updated** dependencies
-  - Commit [#1](https://github.com/dotkernel/api/commit/53d95c5e04eacc339d4ba87d7f94ce3b042e819d)
-  - **require**
-    - "dotkernel/dot-annotated-services": "^4.1.7",
-    - "dotkernel/dot-cli": "^3.5.0",
-    - "dotkernel/dot-data-fixtures": "^1.1.3",
-    - "dotkernel/dot-doctrine-metadata": "^3.2.2",
-    - "dotkernel/dot-errorhandler": "^3.3.2",
-    - "dotkernel/dot-mail": "^4.1.1",
-    - "dotkernel/dot-response-header": "^3.2.3",
-    - "laminas/laminas-component-installer": "^3.4.0",
-    - "laminas/laminas-config": "^3.9.0",
-    - "laminas/laminas-config-aggregator": "^1.14.0",
-    - "laminas/laminas-http": "^2.19.0",
-    - "laminas/laminas-hydrator": "^4.15.0",
-    - "laminas/laminas-inputfilter": "^2.29.0",
-    - "laminas/laminas-paginator": "^2.18.0",
-    - "laminas/laminas-stdlib": "^3.19.0",
-    - "laminas/laminas-text": "^2.11.0",
-    - "mezzio/mezzio": "^3.19.0",
-    - "mezzio/mezzio-authentication-oauth2": "^2.8.0",
-    - "mezzio/mezzio-authorization-acl": "^1.10.0",
-    - "mezzio/mezzio-authorization-rbac": "^1.7.0",
-    - "mezzio/mezzio-cors": "^1.11.1",
-    - "mezzio/mezzio-fastroute": "^3.11.0",
-    - "mezzio/mezzio-problem-details": "^1.13.1",
-    - "mezzio/mezzio-twigrenderer": "^2.15.0",
-    - "ramsey/uuid-doctrine": "^2.0.0",
-    - "roave/psr-container-doctrine": "^4.1.0",
-    - "symfony/filesystem": "^7.0.3"
-  - **require-dev**
-    - "laminas/laminas-coding-standard": "^2.5",
-    - "laminas/laminas-development-mode": "^3.12.0",
-    - "mezzio/mezzio-tooling": "^2.9.0",
-    - "phpunit/phpunit": "^10.5.10",
-    - "roave/security-advisories": "dev-latest",
-    - "vimeo/psalm": "^5.22.0"
-- **Removed** parameter from configuration files and uses for class *PhpFileCache* (previously required by cache)
-  - Updated *config/autoload/doctrine.global.php*
-    - Removed *use Doctrine\Common\Cache\PhpFileCache*
-    - Removed the parameters used by cache *configuration* and *cache*
-  - Commit [#1](https://github.com/dotkernel/api/commit/53d95c5e04eacc339d4ba87d7f94ce3b042e819d)
-  - Make sure to keep the lines from the more recent commit [#2](https://github.com/dotkernel/api/commit/7d5f018f5845e10305d7815ad0b5067148ea68fa)
-- **Added dot-cache**
-  - Updated *composer.json*, *config/autoload/doctrine.global.php* and *config/config.php*
-  - Commit [#1](https://github.com/dotkernel/api/pull/227/files)
-- **Note**
-  - When upgrading from older versions of Dotkernel API (before PHP 8.3), you may need to run *composer update* and/or install Sodium (run *sudo dnf install php-sodium.x86_64*)
-  - Update your queries: replace *useQueryCache()* with *setCacheable()* wherever it's used
+## Supported PHP versions
+
+Dotkernel API now supports only PHP 8.2 and PHP 8.3.
+Support for PHP 8.1 was removed, and the project's CI workflows were updated accordingly.
+
+## Updated dependencies
+
+### require
+
+- `dotkernel/dot-annotated-services`: ^4.1.7
+- `dotkernel/dot-cli`: ^3.5.0
+- `dotkernel/dot-data-fixtures`: ^1.1.3
+- `dotkernel/dot-doctrine-metadata`: ^3.2.2
+- `dotkernel/dot-errorhandler`: ^3.3.2
+- `dotkernel/dot-mail`: ^4.1.1
+- `dotkernel/dot-response-header`: ^3.2.3
+- `laminas/laminas-component-installer`: ^3.4.0
+- `laminas/laminas-config`: ^3.9.0
+- `laminas/laminas-config-aggregator`: ^1.14.0
+- `laminas/laminas-http`: ^2.19.0
+- `laminas/laminas-hydrator`: ^4.15.0
+- `laminas/laminas-inputfilter`: ^2.29.0
+- `laminas/laminas-paginator`: ^2.18.0
+- `laminas/laminas-stdlib`: ^3.19.0
+- `laminas/laminas-text`: ^2.11.0
+- `mezzio/mezzio`: ^3.19.0
+- `mezzio/mezzio-authentication-oauth2`: ^2.8.0
+- `mezzio/mezzio-authorization-acl`: ^1.10.0
+- `mezzio/mezzio-authorization-rbac`: ^1.7.0
+- `mezzio/mezzio-cors`: ^1.11.1
+- `mezzio/mezzio-fastroute`: ^3.11.0
+- `mezzio/mezzio-problem-details`: ^1.13.1
+- `mezzio/mezzio-twigrenderer`: ^2.15.0
+- `ramsey/uuid-doctrine`: ^2.0.0
+- `roave/psr-container-doctrine`: ^4.1.0
+- `symfony/filesystem`: ^7.0.3
+
+### require-dev
+
+- `laminas/laminas-coding-standard`: ^2.5
+- `laminas/laminas-development-mode`: ^3.12.0
+- `mezzio/mezzio-tooling`: ^2.9.0
+- `phpunit/phpunit`: ^10.5.10
+- `roave/security-advisories`: dev-latest
+- `vimeo/psalm`: ^5.22.0
+
+## Caching changes
+
+The `PhpFileCache` class (previously required for cache configuration) and its related parameters were removed from `config/autoload/doctrine.global.php`, including the `use Doctrine\Common\Cache\PhpFileCache` import and the cache-related configuration parameters.
+
+In its place, the `dot-cache` package was added, with corresponding updates made to `composer.json`, `config/autoload/doctrine.global.php`, and `config/config.php`.
+
+## Upgrade notes
+
+- When upgrading from an older version of Dotkernel API (before PHP 8.3 support), you may need to run `composer update` and/or install Sodium, for example via `sudo dnf install php-sodium.x86_64`.
+- Update your queries: replace `useQueryCache()` with `setCacheable()` wherever it is used.
 
 ## FAQ
 
 **Q: What PHP versions does Dotkernel API support after this update?**
-A: Dotkernel API, now at v4.2.1, supports only PHP 8.2 and PHP 8.3. Support for PHP 8.1 was removed, including from the project's workflows.
+A: Dotkernel API, now at v4.2.1, supports only PHP 8.2 and PHP 8.3.
+Support for PHP 8.1 was removed, including from the project's workflows.
 
 **Q: What changed with caching in Dotkernel API?**
-A: The PhpFileCache class and its related parameters were removed from config/autoload/doctrine.global.php, which previously required it for cache configuration. The dot-cache package was added instead, with corresponding updates to composer.json, config/autoload/doctrine.global.php, and config/config.php.
+A: The PhpFileCache class and its related parameters were removed from config/autoload/doctrine.global.php, which previously required it for cache configuration.
+The dot-cache package was added instead, with corresponding updates to composer.json, config/autoload/doctrine.global.php, and config/config.php.
 
 **Q: Do I need to update my Doctrine queries after this update?**
-A: Yes. Wherever useQueryCache() is used in your queries, it should be replaced with setCacheable().
+A: Yes.
+Wherever useQueryCache() is used in your queries, it should be replaced with setCacheable().
 
 **Q: What should I do when upgrading an older Dotkernel API installation to this version?**
 A: When upgrading from a version of Dotkernel API older than the PHP 8.3 support, you may need to run composer update and/or install Sodium, for example by running sudo dnf install php-sodium.x86_64.
 
 **Q: Where can I find the full list of changes for this update?**
 A: The full list of file changes is available in the linked pull request on GitHub for the dotkernel/api repository, and the steps taken mirror those used for the PHP 8.3 update of the Dotkernel Frontend.
+
+## Resources
+
+- [Dotkernel API on GitHub](https://github.com/dotkernel/api)
+- [Dotkernel Frontend on GitHub](https://github.com/dotkernel/frontend)
+- [Full list of file changes (PR #222)](https://github.com/dotkernel/api/pull/222)
diff --git a/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-frontend.md b/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-frontend.md
index 2fa98e0a..03ce3ec6 100644
--- a/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-frontend.md
+++ b/public/md-articles/dotkernel3/php-8-3-support-in-dotkernel-frontend.md
@@ -11,65 +11,24 @@ language: "en"
 # PHP 8.3 support in Dotkernel Frontend
 
 ## TL;DR
+
 To take advantage of PHP 8.3 support in the newest packages, the Dotkernel team updated the [Frontend](https://github.com/dotkernel/frontend) application to version 4.2.0.
 As with the earlier Admin update, this required dropping support for PHP 8.1 and for the no-longer-available `PhpFileCache` class, until a replacement is implemented.
 
-To be able to take advantage of the support for **PHP 8.3** in the newest packages, the Dotkernel team has updated the [Frontend](https://github.com/dotkernel/frontend) Application to version **4.2.0**. Very much like for the Admin update before it, the Frontend must also remove support for PHP 8.1 and the no-longer-available PhpFileCache class until a replacement is implemented.
-
-The full list of file changes is [here](https://github.com/dotkernel/frontend/pull/417).
+## What changed
 
 - **Supports only PHP 8.2 and PHP 8.3**
   - Removed support for PHP 8.1
-  - Updated workflows - removed PHP 8.1
-  - Commit [#1](https://github.com/dotkernel/frontend/commit/e6c3e6495d50e181cfe4ff6a4edec7af12120abf)
-- **Updated** dependencies
-  - Commit [#1](https://github.com/dotkernel/frontend/commit/e6c3e6495d50e181cfe4ff6a4edec7af12120abf)
-  - **require**
-    - "dotkernel/dot-annotated-services": "^4.1.6",
-    - "dotkernel/dot-authorization": "^3.4.1",
-    - "dotkernel/dot-controller": "^3.4.3",
-    - "dotkernel/dot-data-fixtures": "^1.1.3",
-    - "dotkernel/dot-debugbar": "^1.1.5",
-    - "dotkernel/dot-errorhandler": "^3.3.2",
-    - "dotkernel/dot-flashmessenger": "^3.4.2",
-    - "dotkernel/dot-mail": "~3.4 || ^4.1.1",
-    - "dotkernel/dot-navigation": "^3.4.2",
-    - "dotkernel/dot-rbac-guard": "^3.4.3",
-    - "dotkernel/dot-response-header": "^3.2.3",
-    - "dotkernel/dot-session": "^5.4.2",
-    - "dotkernel/dot-twigrenderer": "^3.4.3",
-    - "friendsofphp/proxy-manager-lts": "^1.0.16",
-    - "laminas/laminas-component-installer": "^3.4.0",
-    - "laminas/laminas-config-aggregator": "^1.14.0",
-    - "laminas/laminas-form": "^3.19.1",
-    - "laminas/laminas-i18n": "^2.26.0",
-    - "mezzio/mezzio": "^3.18.0",
-    - "mezzio/mezzio-authorization-rbac": "^1.7.0",
-    - "mezzio/mezzio-cors": "^1.11.1",
-    - "mezzio/mezzio-fastroute": "^3.11.0",
-    - "ramsey/uuid-doctrine": "^2.0.0",
-    - "roave/psr-container-doctrine": "^4.1.0"
-  - **require-dev**
-    - "filp/whoops": "^2.15.4",
-    - "laminas/laminas-development-mode": "^3.12.0",
-    - "mezzio/mezzio-tooling": "^2.9.0",
-    - "phpunit/phpunit": "^10.5",
-    - "rector/rector": "^1.0.0",
-    - "vimeo/psalm": "^5.21.1"
-- **Updated** npm dependencies in *packagist.json*
-  - Recommended to use npm v10.0.4 and Node.js v20.11.0
-  - Commit [#1](https://github.com/dotkernel/frontend/commit/d4d0309c95ba7a572afc82965fdf0e0904a4e0c9) and [#2](https://github.com/dotkernel/frontend/commit/99d8a1fcbebf5d124c9f96cd948b9e28732cfec8)
-- **Removed** parameter from configuration files and uses for class *PhpFileCache* (required by cache)
-  - Updated *doctrine.global.php*
-    - Removed *use Doctrine\Common\Cache\PhpFileCache;*
-    - Removed the parameters used by cache *configuration* and *cache*
-  - Commit [#1](https://github.com/dotkernel/frontend/commit/e6c3e6495d50e181cfe4ff6a4edec7af12120abf)
-  - Make sure to keep the lines from the more recent commit [#2](https://github.com/dotkernel/frontend/commit/f693750602b8c0e5d6582826604ef65a4f0f6b02)
-- **Fixed** psalm and phpcs issues
-  - Updated type hints and indentations
-  - Commits [#1](https://github.com/dotkernel/frontend/commit/2a3e831208aa342220077ee2fd497b3ac4cc823f) and [#2](https://github.com/dotkernel/frontend/commit/a24a3426725417713109f8318bd9b0d53c250945)
+  - Updated CI workflows to remove PHP 8.1
+- **Updated dependencies** in `composer.json` (`require` and `require-dev`), including packages such as `dotkernel/dot-annotated-services`, `dotkernel/dot-controller`, `dotkernel/dot-mail`, `mezzio/mezzio`, `phpunit/phpunit`, `rector/rector`, and `vimeo/psalm`.
+- **Updated npm dependencies** in `packagist.json` - recommended to use npm v10.0.4 and Node.js v20.11.0.
+- **Removed `PhpFileCache` usage** from configuration files (required due to the class no longer being available):
+  - Updated `doctrine.global.php`
+  - Removed the `use Doctrine\Common\Cache\PhpFileCache;` statement
+  - Removed the parameters used by the `configuration` and `cache` cache settings
+- **Fixed Psalm and PHPCS issues** - updated type hints and indentation.
 
-Next on the menu is to implement these changes in the Dotkernel Frontend live projects and process the feedback.
+Next on the roadmap: implementing these changes in the Dotkernel Frontend live projects and processing the feedback.
 
 ## FAQ
 
@@ -77,13 +36,19 @@ Next on the menu is to implement these changes in the Dotkernel Frontend live pr
 A: The Dotkernel team updated the Frontend application to version 4.2.0 so it can take advantage of PHP 8.3 support in the newest packages.
 
 **Q: Which PHP versions does Dotkernel Frontend 4.2.0 support?**
-A: Version 4.2.0 supports only PHP 8.2 and PHP 8.3. Support for PHP 8.1 was removed, similar to the earlier Admin update.
+A: Version 4.2.0 supports only PHP 8.2 and PHP 8.3.
+Support for PHP 8.1 was removed, similar to the earlier Admin update.
 
 **Q: What changed with caching in this update?**
-A: The no-longer-available PhpFileCache class is no longer supported until a replacement is implemented. The related parameters were removed from configuration files, including removing the use Doctrine\Common\Cache\PhpFileCache; statement and the configuration and cache parameters in doctrine.global.php.
+A: The no-longer-available PhpFileCache class is no longer supported until a replacement is implemented. The related parameters were removed from configuration files, including removing the `use Doctrine\Common\Cache\PhpFileCache;` statement and the configuration and cache parameters in `doctrine.global.php`.
 
 **Q: What npm and Node.js versions are recommended for this update?**
 A: Alongside updated npm dependencies in packagist.json, it is recommended to use npm v10.0.4 and Node.js v20.11.0.
 
 **Q: Where can I find the full list of file changes for this update?**
 A: The full list of file changes is linked in the article, pointing to the corresponding pull request on the Dotkernel Frontend GitHub repository.
+
+## Resources
+
+- [Dotkernel Frontend on GitHub](https://github.com/dotkernel/frontend)
+- [Full list of file changes (pull request)](https://github.com/dotkernel/frontend/pull/417)
diff --git a/public/md-articles/headless-platform/complementary-admin-in-dotkernel-headless-platform.md b/public/md-articles/headless-platform/complementary-admin-in-dotkernel-headless-platform.md
index 5262ccec..04ac58b4 100644
--- a/public/md-articles/headless-platform/complementary-admin-in-dotkernel-headless-platform.md
+++ b/public/md-articles/headless-platform/complementary-admin-in-dotkernel-headless-platform.md
@@ -11,78 +11,76 @@ language: "en"
 # Complementary Admin in Dotkernel Headless Platform
 
 ## TL;DR
+
 The Dotkernel Headless Platform's core components are Dotkernel API and Dotkernel Queue, but the suite also offers a fully separate, complementary **Admin** application designed to pair seamlessly with Dotkernel API.
 Admin is an independent app built on the same Mezzio + Laminas foundation, sharing a unified tech stack with the API so the two form a cohesive, consistent system.
 
-The Dotkernel Headless Platform is built with an architecture designed to be easy to maintain and expand indefinitely. Its core components are Dotkernel API and Dotkernel Queue, but the Dotkernel application suite also offers a fully separate, **complementary Admin** application designed to pair seamlessly with Dotkernel API.
-
 ## What is Dotkernel Admin?
 
-**Dotkernel Admin** is a in separate repository and is a fully-functional, independent application. It's built on top of the same Mezzio + Laminas foundation, very much like Dotkernel API.
-
-As with all Dotkernel applications, Admin is installed via Git within your folder of choice:
+Dotkernel Admin lives in its own separate repository and is a fully-functional, independent application.
+It's built on top of the same Mezzio + Laminas foundation as Dotkernel API, and comes with a built-in UI including authentication, user management and a web interface.
 
-```
-git clone https://github.com/dotkernel/admin.git .
-```
+### Installation
 
-Next follow the step-by-step [installation guide](https://docs.dotkernel.org/admin-documentation/v5/installation/getting-started/) to configure the database credentials and run migrations and fixtures that create and populate the database. It takes only a few minutes and you’ll have a ready-to-use admin panel.
+1. Clone the repository into your folder of choice:
+   ```shell
+   git clone https://github.com/dotkernel/admin.git .
+   ```
+2. Follow the step-by-step [installation guide](https://docs.dotkernel.org/admin-documentation/v5/installation/getting-started/) to configure the database credentials and run the migrations and fixtures that create and populate the database.
+This takes only a few minutes and results in a ready-to-use admin panel.
 
-> Make sure to **change the default credentials** when in production.
-
-The Admin has a built-in UI with authentication, user management and web interface included.
+> Make sure to change the default credentials when in production.
 
 ## Features & Architecture
 
 Dotkernel Admin comes with several useful features out of the box:
 
-- The **Role-Based Access Control** uses [dot-rbac](https://docs.dotkernel.org/dot-rbac/) and [dot-rbac-guard](https://docs.dotkernel.org/dot-rbac-guard/) to manage permissions, routes and handler-level security.
-- **OpenAPI** annotations are included in each module via OpenAPI.php, making admin endpoints documented and testable.
-- The **Frontend tooling** uses [Twig](https://twig.symfony.com/) and [NodeJS/NPM](https://www.npmjs.com/) for client-side assets, which include `build` and `watch` scripts to manage JavaScript/CSS bundling.
+- **Role-Based Access Control** using [dot-rbac](https://docs.dotkernel.org/dot-rbac/) and [dot-rbac-guard](https://docs.dotkernel.org/dot-rbac-guard/) to manage permissions, routes and handler-level security.
+- **OpenAPI** annotations included in each module via `OpenAPI.php`, making admin endpoints documented and testable.
+- **Frontend tooling** using [Twig](https://twig.symfony.com/) and [NodeJS/NPM](https://www.npmjs.com/) for client-side assets, including `build` and `watch` scripts to manage JavaScript/CSS bundling.
 
-The file architecture features a modular design with several functional modules such as:
+The file architecture features a modular design with several functional modules:
 
-- The **Admin module** which manages administrator users.
-- The **App module** which houses core functions like authentication and error reporting.
-- The **Setting module** which stores and manages display or application settings for various report pages.
+| Module | Responsibility |
+|---|---|
+| Admin module | Manages administrator users |
+| App module | Houses core functions like authentication and error reporting |
+| Setting module | Stores and manages display or application settings for various report pages |
 
 ## How They Work Together
 
 - The [REST API](https://github.com/dotkernel/api) is designed to serve JSON endpoints for clients, services and mobile apps alike.
 - The [Admin UI](https://github.com/dotkernel/admin) is a web-based interface that communicates with the database via its own endpoints to manage data, users and settings.
 
-One of the greatest benefits to using both Dotkernel API and Admin is the **unified tech stack**. Both use the versatile [Mezzio microframework](https://docs.mezzio.dev/), [Laminas components](https://docs.laminas.dev/), [Doctrine ORM](https://www.doctrine-project.org/) for database storage and object mapping, [PHP FIG's PSR standards](https://www.php-fig.org/) and share modules like authentication and `dot-rbac`.
+One of the greatest benefits to using both Dotkernel API and Admin is the **unified tech stack**.
+Both use the [Mezzio microframework](https://docs.mezzio.dev/), [Laminas components](https://docs.laminas.dev/), [Doctrine ORM](https://www.doctrine-project.org/) for database storage and object mapping, [PHP FIG's PSR standards](https://www.php-fig.org/), and share modules like authentication and `dot-rbac`.
 
-Put together, these ensure consistency across backend and admin tooling, while also making it easier to switch between developing one or the other. In fact, the similar architecture normally means you can employ fewer developers to manage codebases.
+Put together, these ensure consistency across backend and admin tooling, while also making it easier to switch between developing one or the other.
+The similar architecture normally means fewer developers are needed to manage the codebases.
 
 ## Summary
 
-Dotkernel Admin is a **complementary admin** panel that provides effective reporting out of the box and is a good starting point for your admin requirements. It's not bundled by default, but is provided as a first-party, installable package designed to work seamlessly alongside your API.
-
-Together, the two applications form a **cohesive system**. You normally start with the API backend and add the rich administrative interface to the mix to complete your admin platform.
+Dotkernel Admin is a complementary admin panel that provides effective reporting out of the box and is a good starting point for admin requirements.
+It's not bundled by default, but is provided as a first-party, installable package designed to work seamlessly alongside the API.
 
-Both API and Admin are built with the **same underlying file architecture** and implement the **same PHP standards** - [PSR-7 (HTTP messages)](https://www.php-fig.org/psr/psr-7/) and [PSR-15 (middleware)](https://github.com/php-fig/http-server-handler).
+Together, the two applications form a cohesive system: you normally start with the API backend and add the rich administrative interface to complete your admin platform.
+Both are built with the same underlying file architecture and implement the same PHP standards - [PSR-7 (HTTP messages)](https://www.php-fig.org/psr/psr-7/) and [PSR-15 (middleware)](https://github.com/php-fig/http-server-handler).
 
-If you're looking for a headless API with a ready-to-use admin UI that you can launch quickly, the Dotkernel solution is the way to go. Here are some of the benefits for both components:
+Benefits of both components:
 
-- They are fully open-source and in active development.
-- They are highly configurable to suit your exact requirements.
-- They guarantee a future-proof system using the best practices recommended by the PHP community.
-
-## Additional Resources
-
-- [Dotkernel Admin full documentation](https://docs.dotkernel.org/admin-documentation/)
-- [Dotkernel Admin Installation](https://docs.dotkernel.org/admin-documentation/v5/installation/getting-started/)
-- [Dotkernel Repositories](https://github.com/dotkernel)
-- [PHP Framework Interop Group Standards](https://www.php-fig.org/)
+- Fully open-source and in active development.
+- Highly configurable to suit exact requirements.
+- Guarantee a future-proof system using the best practices recommended by the PHP community.
 
 ## FAQ
 
 **Q: What is Dotkernel Admin?**
-A: Dotkernel Admin is a fully-functional, independent application that lives in its own separate repository. It's built on the same Mezzio + Laminas foundation as Dotkernel API and includes a built-in UI with authentication, user management and a web interface.
+A: Dotkernel Admin is a fully-functional, independent application that lives in its own separate repository.
+It's built on the same Mezzio + Laminas foundation as Dotkernel API and includes a built-in UI with authentication, user management and a web interface.
 
 **Q: How do I install Dotkernel Admin?**
-A: Install it via Git into the folder of your choice with git clone https://github.com/dotkernel/admin.git ., then follow the step-by-step installation guide to configure the database credentials and run the migrations and fixtures that create and populate the database. Be sure to change the default credentials before going to production.
+A: Install it via Git into the folder of your choice with `git clone https://github.com/dotkernel/admin.git .`, then follow the step-by-step installation guide to configure the database credentials and run the migrations and fixtures that create and populate the database.
+Be sure to change the default credentials before going to production.
 
 **Q: What features does Dotkernel Admin include out of the box?**
 A: It ships with Role-Based Access Control powered by dot-rbac and dot-rbac-guard to manage permissions, routes and handler-level security; OpenAPI annotations in each module for documented and testable admin endpoints; and frontend tooling built on Twig and NodeJS/NPM, including build and watch scripts for JavaScript/CSS bundling.
@@ -91,4 +89,12 @@ A: It ships with Role-Based Access Control powered by dot-rbac and dot-rbac-guar
 A: The file architecture is modular, featuring an Admin module that manages administrator users, an App module that houses core functions like authentication and error reporting, and a Setting module that stores and manages display or application settings for various report pages.
 
 **Q: How do Dotkernel API and Admin work together?**
-A: The REST API serves JSON endpoints for clients, services and mobile apps, while the Admin UI is a web-based interface that communicates with the database via its own endpoints to manage data, users and settings. Both share a unified tech stack - Mezzio, Laminas components, Doctrine ORM and PHP FIG's PSR standards - plus shared modules like authentication and dot-rbac, which keeps backend and admin tooling consistent and lets fewer developers manage both codebases.
+A: The REST API serves JSON endpoints for clients, services and mobile apps, while the Admin UI is a web-based interface that communicates with the database via its own endpoints to manage data, users and settings.
+Both share a unified tech stack - Mezzio, Laminas components, Doctrine ORM and PHP FIG's PSR standards - plus shared modules like authentication and dot-rbac, which keeps backend and admin tooling consistent and lets fewer developers manage both codebases.
+
+## Resources
+
+- [Dotkernel Admin full documentation](https://docs.dotkernel.org/admin-documentation/)
+- [Dotkernel Admin Installation](https://docs.dotkernel.org/admin-documentation/v5/installation/getting-started/)
+- [Dotkernel Repositories](https://github.com/dotkernel)
+- [PHP Framework Interop Group Standards](https://www.php-fig.org/)
diff --git a/public/md-articles/headless-platform/dotkernel-api-v6-the-root-of-dotkernel-headless-platform.md b/public/md-articles/headless-platform/dotkernel-api-v6-the-root-of-dotkernel-headless-platform.md
index 74f718d9..efbb7569 100644
--- a/public/md-articles/headless-platform/dotkernel-api-v6-the-root-of-dotkernel-headless-platform.md
+++ b/public/md-articles/headless-platform/dotkernel-api-v6-the-root-of-dotkernel-headless-platform.md
@@ -11,46 +11,44 @@ language: "en"
 # Dotkernel API v6: The root of Dotkernel Headless Platform
 
 ## TL;DR
+
 Dotkernel API has evolved significantly since its original architecture and components article, adding Content Negotiation, standardized error responses via mezzio-problem-details, a shareable Core module, a custom templating solution replacing Twig, and a leaner handler dependency setup.
 Packages were updated across the board, the test suite switched from Psalm to PHPStan at a stricter rule level, and the roadmap for v6.1 targets Service Manager 4 and PHP 8.4/8.5 support.
 
-Dotkernel API has come a long way since we published a list of its [architecture and components](https://www.dotkernel.com/dotkernel3/dotkernel-api-architecture-and-components/) a while ago. We implemented new features, while some components were replaced, and others were enhanced. Our ultimate goal is to stay relevant in the PHP ecosystem by implementing best practices recommended by the PHP community.
-
 ## New Features
 
-- **Content Negotiation** makes it possible for diverse systems to work seamlessly together. It defines the communication parameters between client and server to make sure both sides agree on how the data exchange takes place.
-- The implemented of [mezzio-problem-details](https://github.com/mezzio/mezzio-problem-details) is used to return **standardized error codes**. The generated problem details responses are based on either PHP primitives or exceptions/throwables. This ultimately helps **error reporting** system-wide.
-- The common logic is now moved to the **Core module**. This also allows an easier **sharing** of the **functionality** within Core with other Dotkernel applications. To share the Code module, you need to save it as a separate Git repository which can then be added as a **submodule** to any Dotkernel application.
-- Replaced Twig with **custom templating** solution to avoid using [mezzio-twigrenderer](https://github.com/mezzio/mezzio-twigrenderer). This ultimately offers more reliable template handling as the small cost of some features that are normally not used in APIs.
-- Handle delegators and injected InputFilters were refactored to **reduce the number of dependencies in handlers**.
+- **Content Negotiation** makes it possible for diverse systems to work seamlessly together, defining the communication parameters between client and server so both sides agree on how the data exchange takes place.
+- **Standardized error codes**, implemented via [mezzio-problem-details](https://github.com/mezzio/mezzio-problem-details), returning problem details responses based on either PHP primitives or exceptions/throwables to help error reporting system-wide.
+- A new **Core module** holding common logic, making it easier to share that functionality with other Dotkernel applications.
+To reuse it, the Core module is saved as a separate Git repository, which can then be added as a submodule to any Dotkernel application.
+- **Custom templating solution** replacing Twig, avoiding the use of [mezzio-twigrenderer](https://github.com/mezzio/mezzio-twigrenderer).
+This offers more reliable template handling, at the small cost of some features that are normally not used in APIs.
+- Refactored **handle delegators** and **injected InputFilters**, reducing the number of dependencies in handlers.
 
-Some smaller changes are listed below:
+Smaller changes:
 
 - Added OpenAPI documentation for all endpoints.
-- Added .gitattributes to set some git properties based on path and filename.
+- Added `.gitattributes` to set some git properties based on path and filename.
 - Implemented enums in the database, where relevant, mostly as a proof of concept.
 
-### Coming Soon
-
-Currently we support:
-
-- Service Manager version 3 - restricted because of constraints from some dependencies.
-- PHP 8.3.
+## Coming Soon
 
-This setup is soon going to change. The very next version in the Roadmap for version 6.1 will implement:
+| | Currently supported | Planned for v6.1 |
+|---|---|---|
+| Service Manager | Version 3 (restricted because of constraints from some dependencies) | Version 4 |
+| PHP | 8.3 | 8.4 and 8.5 |
 
-- Service Manager 4.
-- Support for PHP 8.4 and 8.5.
+## Composer Updates
 
-## Composer updates
+All packages were updated to their most recent versions that still allow for an installable set of dependencies.
 
-As with all regular updates, all **packages** were **updated to their most recent versions** that still allow for an installable set of dependencies.
+One package that stands out is [ramsey/uuid](https://github.com/ramsey/uuid).
+UUID version 7 is already being used in ramsey/uuid version 4, so it will be available with no additional code changes once ramsey/uuid version 5 is released.
 
-One of the packages that stands out is [ramsey/uuid](https://github.com/ramsey/uuid). **UUID version 7** is already being used for ramsey/uuid version 4 and thus will be available with no additional code changes for the release of ramsey/uuid version 5.
+## Tweaked Configuration and Testing
 
-## Tweaked configuration and testing
-
-Alongside some smaller changes related to cache configuration for doctrine and route grouping, the **test suite** has been revised. [Psalm](https://psalm.dev/) has been replaced with [PHPStan](https://phpstan.org/). This decision was made to remain in line with developers from popular projects like Doctrine and Composer who have also made the switch recently. A separate upgrade was dedicated to increasing the **rule level to 8** which enables stricter static analysis and reveales more potential errors.
+Alongside smaller changes related to cache configuration for Doctrine and route grouping, the test suite has been revised: [Psalm](https://psalm.dev/) has been replaced with [PHPStan](https://phpstan.org/), a decision made to remain in line with developers from popular projects like Doctrine and Composer, who have also made the switch recently.
+A separate upgrade increased the rule level to 8, enabling stricter static analysis and revealing more potential errors.
 
 ## FAQ
 
@@ -58,13 +56,26 @@ Alongside some smaller changes related to cache configuration for doctrine and r
 A: Dotkernel API v6 adds Content Negotiation for smoother communication between client and server, standardized error codes via mezzio-problem-details, a new Core module that centralizes common logic for easier sharing across Dotkernel applications, a custom templating solution that replaces Twig/mezzio-twigrenderer, and refactored handle delegators and injected InputFilters that reduce the number of dependencies in handlers.
 
 **Q: Why was common logic moved into a Core module?**
-A: Moving the shared logic into a Core module makes it easier to reuse that functionality across other Dotkernel applications. The Core module can be saved as a separate Git repository and then added as a submodule to any Dotkernel application.
+A: Moving the shared logic into a Core module makes it easier to reuse that functionality across other Dotkernel applications.
+The Core module can be saved as a separate Git repository and then added as a submodule to any Dotkernel application.
 
 **Q: Why did Dotkernel API replace Twig with a custom templating solution?**
-A: Twig was replaced to avoid depending on mezzio-twigrenderer. The custom solution offers more reliable template handling, at the small cost of some features that are normally not used in APIs anyway.
+A: Twig was replaced to avoid depending on mezzio-twigrenderer.
+The custom solution offers more reliable template handling, at the small cost of some features that are normally not used in APIs anyway.
 
 **Q: What is planned for Dotkernel API v6.1?**
-A: Dotkernel API currently supports Service Manager version 3, restricted because of constraints from some dependencies, and PHP 8.3. The next version on the roadmap, v6.1, is planned to add support for Service Manager 4 as well as PHP 8.4 and 8.5.
+A: Dotkernel API currently supports Service Manager version 3, restricted because of constraints from some dependencies, and PHP 8.3.
+The next version on the roadmap, v6.1, is planned to add support for Service Manager 4 as well as PHP 8.4 and 8.5.
 
 **Q: Why was Psalm replaced with PHPStan in the test suite?**
-A: Psalm was replaced with PHPStan to remain in line with developers from popular projects like Doctrine and Composer, who have also made the switch. A separate upgrade also increased the rule level to 8, enabling stricter static analysis and revealing more potential errors.
+A: Psalm was replaced with PHPStan to remain in line with developers from popular projects like Doctrine and Composer, who have also made the switch.
+A separate upgrade also increased the rule level to 8, enabling stricter static analysis and revealing more potential errors.
+
+## Resources
+
+- [Dotkernel API architecture and components (original article)](https://www.dotkernel.com/dotkernel3/dotkernel-api-architecture-components/)
+- [mezzio-problem-details on GitHub](https://github.com/mezzio/mezzio-problem-details)
+- [mezzio-twigrenderer on GitHub](https://github.com/mezzio/mezzio-twigrenderer)
+- [ramsey/uuid on GitHub](https://github.com/ramsey/uuid)
+- [Psalm](https://psalm.dev/)
+- [PHPStan](https://phpstan.org/)
diff --git a/public/md-articles/headless-platform/dotkernel-headless-platform-the-whats-hows-and-whys.md b/public/md-articles/headless-platform/dotkernel-headless-platform-the-whats-hows-and-whys.md
index f4e62981..1bb19c9c 100644
--- a/public/md-articles/headless-platform/dotkernel-headless-platform-the-whats-hows-and-whys.md
+++ b/public/md-articles/headless-platform/dotkernel-headless-platform-the-whats-hows-and-whys.md
@@ -11,63 +11,62 @@ language: "en"
 # Dotkernel Headless Platform - The Whats, Hows and Whys
 
 ## TL;DR
+
 A Headless Platform decouples the frontend (UI) from the backend services, with responses consumed by another system such as a website or mobile app. The Dotkernel Headless Platform is made up of Dotkernel API (a REST API based on the Mezzio skeleton) and Dotkernel Admin (a backend management interface), which can be installed separately or together.
 Using both together, sharing a common Core module, gives consistent entities and queries, an easy-to-maintain shared file structure, and an architecture that scales from small microservices to enterprise-grade APIs.
 
-The principle of a **Headless Platform** is to decouple the User Interface (**frontend**) from the **backend** services. The responses from the platform are then used by another system, such as a website or mobile app. In this article we will explore the Dotkernel implementation of the **Headless Platform** architecture, how to use it and what are its benefits.
-
 ## Components of the Dotkernel Headless Platform
 
-The Dotkernel Headless Platform contains 2 major components:
-
-- [Dotkernel API](https://www.dotkernel.org).
-- [Dotkernel Admin](https://github.com/dotkernel/admin).
-
-**Dotkernel API** is a REST API based on the [**Mezzio skeleton**](https://github.com/mezzio/mezzio-skeleton).
+The Dotkernel Headless Platform contains two major components:
 
-**Dotkernel Admin**, a complementary component for the API, is aimed at quickly setting up an backend for your platform.
+- [Dotkernel API](https://www.dotkernel.org) - a REST API based on the [Mezzio skeleton](https://github.com/mezzio/mezzio-skeleton).
+- [Dotkernel Admin](https://github.com/dotkernel/admin) - a complementary component aimed at quickly setting up a backend for your platform.
 
-The Admin is not bundled by default but is available as a first-party, installable application designed to work seamlessly alongside your API. When the API and Admin are put together, you gain a cohesive system that contains an API-first backend with a rich administrative interface, both built with the same underlying architecture and standards support.
+The Admin is not bundled by default but is available as a first-party, installable application designed to work seamlessly alongside your API.
+Together, they form a cohesive system: an API-first backend paired with a rich administrative interface, both built on the same underlying architecture and standards.
 
-Both of the above have a PSR-Compliant Middleware Stack to promote a lean, modular architecture and create a common ground between components from various sources. They implement [PSR-7](https://www.php-fig.org/psr/psr-7) and [PSR-15](https://www.php-fig.org/psr/psr-15) as defined by the [PHP Framework Interop Group](https://www.php-fig.org/).
+Both components use a PSR-compliant middleware stack, implementing [PSR-7](https://www.php-fig.org/psr/psr-7) and [PSR-15](https://www.php-fig.org/psr/psr-15) as defined by the [PHP Framework Interop Group](https://www.php-fig.org/), promoting a lean, modular architecture.
 
-Rather than making use of elements built into the framework, you **build business logic from scratch**, from handlers, to dependencies. This gives you **full control** over business logic and data architecture.
+Rather than relying on elements built into the framework, business logic is built from scratch - from handlers to dependencies - giving full control over business logic and data architecture.
 
-## How to use the Dotkernel Headless Platform
+## How to Use the Dotkernel Headless Platform
 
-Dotkernel API and Admin can be **installed separately or together**, based on your business requirements. The two are normally designed to **complement each other**:
+Dotkernel API and Admin can be installed separately or together, based on business requirements.
+They are normally designed to complement each other:
 
 - Dotkernel **Admin** manages the data (create, edit, delete).
 - Dotkernel **API** exposes the content to 3rd-party frontends or backends.
 
-A simple project can be designed around one of the two at first, then expand to the other. For example, you can **start with Dotkernel Admin** to populate your database. Later on you can employ Dotkernel API to present the data to other frontends written in your programming language of choice. You can integrate the API with 3rd-party applications which gives you full control over how you present the data.
+A simple project can be designed around one of the two at first, then expand to the other:
 
-Alternatively, you can **start with Dotkernel API** and integrate it into your existing platform. The API can manage the access permissions to keep your data secure:
+- **Start with Dotkernel Admin** to populate your database, then later use Dotkernel API to present the data to other frontends written in any programming language, integrating with 3rd-party applications for full control over how data is presented.
+- **Start with Dotkernel API** and integrate it into an existing platform.
+The API can manage access permissions to keep data secure - admins create and edit data for the backend, while users read data for the frontend.
+Admin can be added later for its simple table-based approach, reports, and graphs.
 
-- Admins create and edit the data for your existing **backend**.
-- Users read the data for your **frontend**.
+The recommendation is to use both API and Admin from the start.
 
-The Admin can be added later on for its simple table-based approach, its reports and graphs.
+## Benefits of the Dotkernel Headless Platform Architecture
 
-Our recommendation is to use both API and Admin from the get go. We will highlight the benefits of this setup in the next chapter.
+Using both API and Admin together brings several benefits:
 
-## Benefits of the Dotkernel Headless Platform architecture
+### Common code between applications
 
-As we mentioned before, you decide what components of the Dotkernel Headless Platform are installed in your project. If you decide to use both, you gain several benefits, as we will highlight below.
-
-### Can be set up to have common code between applications
-
-You can configure the file structure to use a **Core** module. The Core then becomes the common code repository between API and Admin, ensuring that the entities and queries are the same. The **entities** for your platform, whether they be products, articles or something else are the building blocks of your application. The **queries** interact with the entities for CRUD purposes. By having these components in a single repository used in both API and Admin, you ensure consistency when interacting with them.
+The file structure can be configured to use a **Core** module - a common code repository shared between API and Admin, ensuring entities and queries stay consistent.
+Entities (products, articles, etc.) are the building blocks of the application, and queries handle CRUD interactions with them.
 
 ![](/uploads/article/019f8a80-cc94-7123-80d3-9c21a30c19ea/Core2.png)
 
 ### Implement only the handlers you need
 
-Just because you have e.g. 20 entities in your Core doesn't mean you have to implement handlers for each one in both API and Admin. You only **handle what you need** in each application. For example, your shop may need to edit orders in Admin, but only build monthly sales reports via your API.
+Having many entities in the Core doesn't require implementing handlers for each one in both API and Admin.
+Each application only handles what it needs - for example, a shop may need to edit orders in Admin but only build monthly sales reports via the API.
 
-### Has a shared file structure
+### Shared file structure
 
-Another advantage is the fact that the API and Admin **share a file structure**. When you become familiar with one, you're good to go with the other as well. This means that **onboarding is easy** and can be **maintained by fewer developers**, maybe even a single developer, at least in the beginning. Conversely, working with an API+Angular approach means you often need 2 developers working in concert to implement any new feature.
+API and Admin share a file structure, so becoming familiar with one makes the other easy to pick up.
+This means onboarding is easy and the applications can be maintained by fewer developers - potentially a single developer, at least initially.
+By contrast, an API+Angular approach often needs two developers working together to implement a new feature.
 
 ![](/uploads/article/019f8a80-cc94-7123-80d3-9c21a30c19ea/files-api.jpg)
 
@@ -75,53 +74,54 @@ Another advantage is the fact that the API and Admin **share a file structure**.
 
 ### Can satisfy any application size
 
-Thanks to its use of the common Core module, the API and Admin evolve together. The pair are a good starting point for anything **from microservices, to enterprise-grade APIs**. The initial learning curve is worth it, considering you have a large number of packages available for integrating into your platform. You decide exactly what modules to include, meaning the finished application is more lightweight. This prevents bloat and helps with technical debt in the long run.
-
-### Has a versatile architecture
+Thanks to the shared Core module, API and Admin evolve together, forming a good starting point for anything from microservices to enterprise-grade APIs.
+A large number of packages are available for integration, and developers decide exactly what modules to include, keeping the finished application lightweight and preventing bloat and long-term technical debt.
 
-The aim of the architecture implemented in Dotkernel applications is to provide solutions that follow several architectural designs.
+### Versatile architecture
 
-#### Clean Architecture
+The Dotkernel architecture aims to support several architectural designs:
 
-The software components are organized into concentric layers. Code dependencies go from the outer to the inner layers which results in improved testability and independence from components like libraries, user interfaces and databases.
+- **Clean Architecture** - software components are organized into concentric layers, with code dependencies flowing from outer to inner layers, improving testability and independence from libraries, UI, and databases.
+- **Domain-Driven Design (DDD)** - the focus is on custom solutions for business logic; rather than building reusable services for a Service Oriented Architecture (SOA), only the specific components needed to satisfy requirements are implemented.
+- **Hexagonal Architecture** - divides a system into several loosely-coupled, interchangeable components (application core, database, user interface, test scripts, interfaces with other systems), as an alternative to traditional layered architecture.
 
 ![](/uploads/article/019f8a80-cc94-7123-80d3-9c21a30c19ea/Flow2.png)
 
-#### Domain-Driven Design (DDD)
-
-The main focus of the Dotkernel applications is to provide a custom solution for your business logic. Rather than implementing reusable services for a Service Oriented Architecture (SOA), we encourage DDD which only implements the specific components to satisfy your requirements.
-
-#### Hexagonal Architecture
-
-The hexagonal architecture divides a system into several loosely-coupled interchangeable components, such as the application core, the database, the user interface, test scripts and interfaces with other systems. This approach is an alternative to the traditional layered architecture.
-
 ### Supported by an active community
 
-The Dotkernel development team is actively working on investigating and implementing recommended design patterns. All Dotkernel applications and a large number of packages are still receiving updates that implement bugfixes, improvements and recommendations from the PHP community. Some updates may brake BC (backward compatibility), but this is often highlighted in companion articles that may also contain step-by-step tutorials. The Dotkernel team is available to help you with any issues related to the Dotkernel and Laminas apps and components.
-
-## Additional Resources
-
-- [Dotkernel API](https://github.com/dotkernel/api)
-- [Dotkernel Admin](https://github.com/dotkernel/admin)
-- [Dotkernel repositories](https://github.com/dotkernel)
-- [Dotkernel documentation](https://docs.dotkernel.org/)
-- [Headless CMS vs. Traditional CMS: What's Right for PHP Apps?](https://www.zend.com/blog/headless-cms-vs-traditional-cms)
-- [Laminas github discussions](https://github.com/orgs/laminas/discussions)
-- [Dotkernel Discussions](https://github.com/orgs/dotkernel/discussions)
+The Dotkernel development team actively investigates and implements recommended design patterns.
+Dotkernel applications and packages continue to receive updates with bugfixes, improvements, and recommendations from the PHP community.
+Some updates may break backward compatibility, but this is typically highlighted in companion articles that may include step-by-step tutorials.
+The Dotkernel team is available to help with issues related to Dotkernel and Laminas apps and components.
 
 ## FAQ
 
 **Q: What is a Headless Platform?**
-A: A Headless Platform decouples the User Interface (frontend) from the backend services. The responses from the platform are then used by another system, such as a website or mobile app.
+A: A Headless Platform decouples the User Interface (frontend) from the backend services.
+The responses from the platform are then used by another system, such as a website or mobile app.
 
 **Q: What are the two main components of the Dotkernel Headless Platform?**
-A: The Dotkernel Headless Platform contains two major components: Dotkernel API, a REST API based on the Mezzio skeleton, and Dotkernel Admin, a complementary component aimed at quickly setting up a backend. The Admin is not bundled by default but is available as a first-party, installable application designed to work alongside the API.
+A: The Dotkernel Headless Platform contains two major components: Dotkernel API, a REST API based on the Mezzio skeleton, and Dotkernel Admin, a complementary component aimed at quickly setting up a backend.
+The Admin is not bundled by default but is available as a first-party, installable application designed to work alongside the API.
 
 **Q: Can Dotkernel API and Admin be installed separately?**
-A: Yes. They can be installed separately or together, based on your business requirements. You can start with Dotkernel Admin to populate your database and later add Dotkernel API to present the data to other frontends, or start with Dotkernel API and integrate it into your existing platform, adding Admin later for its table-based approach, reports, and graphs.
+A: Yes.
+They can be installed separately or together, based on your business requirements.
+You can start with Dotkernel Admin to populate your database and later add Dotkernel API to present the data to other frontends, or start with Dotkernel API and integrate it into your existing platform, adding Admin later for its table-based approach, reports, and graphs.
 
 **Q: What benefits come from using both API and Admin together?**
-A: Using both together lets you share a common Core module containing the same entities and queries between the two applications, implement only the handlers you actually need, and benefit from a shared file structure that makes onboarding easy and can be maintained by fewer developers. This setup can also satisfy any application size, from microservices to enterprise-grade APIs.
+A: Using both together lets you share a common Core module containing the same entities and queries between the two applications, implement only the handlers you actually need, and benefit from a shared file structure that makes onboarding easy and can be maintained by fewer developers.
+This setup can also satisfy any application size, from microservices to enterprise-grade APIs.
 
 **Q: What architectural patterns does the Dotkernel Headless Platform follow?**
 A: The architecture is designed to be versatile, following Clean Architecture (concentric layers with dependencies flowing from outer to inner layers), Domain-Driven Design (implementing only the specific components needed for your business logic rather than generic reusable services), and Hexagonal Architecture (dividing the system into loosely-coupled, interchangeable components).
+
+## Resources
+
+- [Dotkernel API](https://github.com/dotkernel/api)
+- [Dotkernel Admin](https://github.com/dotkernel/admin)
+- [Dotkernel repositories](https://github.com/dotkernel)
+- [Dotkernel documentation](https://docs.dotkernel.org/)
+- [Headless CMS vs. Traditional CMS: What's Right for PHP Apps?](https://www.zend.com/blog/headless-cms-vs-traditional-cms)
+- [Laminas GitHub discussions](https://github.com/orgs/laminas/discussions)
+- [Dotkernel Discussions](https://github.com/orgs/dotkernel/discussions)
diff --git a/public/md-articles/headless-platform/dotkernel-queue-asynchronous-execution-in-dotkernel-headless-platform.md b/public/md-articles/headless-platform/dotkernel-queue-asynchronous-execution-in-dotkernel-headless-platform.md
index 0d3a8ae8..7b43665a 100644
--- a/public/md-articles/headless-platform/dotkernel-queue-asynchronous-execution-in-dotkernel-headless-platform.md
+++ b/public/md-articles/headless-platform/dotkernel-queue-asynchronous-execution-in-dotkernel-headless-platform.md
@@ -11,122 +11,119 @@ language: "en"
 # Dotkernel Queue - Asynchronous Execution in Dotkernel Headless Platform
 
 ## TL;DR
+
 Dotkernel Queue is a component built on Symfony Messenger (via the netglue/laminas-messenger adapter) that lets time-consuming or resource-intensive operations run asynchronously on background workers instead of inside the normal PHP request-response cycle.
 An active daemon listens for TCP connections, stores incoming messages in Redis, and processes them in FIFO order, with logging, IP-whitelisting security, a configurable retry mechanism, reporting metrics, and a Dead Letter Queue for messages that fail.
 Priorities and parallel execution are planned future features.
 
-[Dotkernel Queue](https://github.com/dotkernel/queue) is a component based on [Symfony Messenger](https://github.com/symfony/messenger) that is used to queue asynchronous tasks. [netglue/laminas-messenger](https://github.com/netglue/laminas-messenger) is an adapter that integrates Symfony Messenger with the [Laminas Service Manager](https://docs.laminas.dev/laminas-servicemanager/) container for Mezzio/Laminas applications.
+## What Dotkernel Queue Is
+
+Dotkernel Queue is a component based on Symfony Messenger that is used to queue asynchronous tasks. netglue/laminas-messenger is an adapter that integrates Symfony Messenger with the Laminas Service Manager container for Mezzio/Laminas applications.
 
-Some everyday **operations are time-consuming and resource-intensive**, so it's best if they run on separate machines, decoupled from the regular request-response cycle. With the addition of **asynchronous execution** performed by background workers, you can ensure that these operations are not lost, terminated by PHP because of timeouts, or interrupted by new requests. The most important benefit is that you **prevent the main platform from overloading**, allowing it to return a response, remain responsive for new requests, while the heavy lifting is scheduled to run later.
+Some everyday operations are time-consuming and resource-intensive, so it's best if they run on separate machines, decoupled from the regular request-response cycle.
+Asynchronous execution performed by background workers ensures these operations are not lost, terminated by PHP timeouts, or interrupted by new requests.
+The main benefit is preventing the main platform from overloading, so it can return a response and remain responsive to new requests while the heavy lifting is scheduled to run later.
 
-> The main goal for the queue is to NOT have the main platform wait for a response, because the queue will execute the task sometime in the future. The regular request-response cycle must be completed swiftly by the main platform, possibly with a confirmation message. After that, the main platform can check with the queue regularly to see if the requested task was completed.
+The main goal for the queue is to not have the main platform wait for a response, because the queue executes the task sometime in the future.
+The regular request-response cycle is completed swiftly by the main platform, possibly with a confirmation message; afterward, the main platform can check with the queue regularly to see if the requested task was completed.
 
 ## Why Use Dotkernel Queue?
 
-You might be inclined to go straight to Symfony Messenger and remove the middle man. There are several benefits that you gain from using Dotkernel Queue:
+Instead of going straight to Symfony Messenger, using Dotkernel Queue offers several benefits:
 
-- It uses the Symfony Messenger mechanisms at its heart. Symfony Messenger will be kept updated as new updates are released.
-- netglue/laminas-messenger turns the component into a middleware which is compatible with Mezzio/Laminas.
-- It is seamlessly compatible with the Dotkernel Headless Platform, because it has the same file structure and supports the same Core submodule. The Core submodule is shared by other Dotkernel applications suite (Frontend, API, Admin) and ensures consistency across your platform.
-- Dotkernel Queue is a standalone application in its own right, so it can also be added more easily in your existing platform.
-- We implemented queue features that we use in our own projects, so we can quarantee their worth in live projects.
+- It uses the Symfony Messenger mechanisms at its heart, so it stays updated as Symfony Messenger releases updates.
+- netglue/laminas-messenger turns the component into middleware compatible with Mezzio/Laminas.
+- It is seamlessly compatible with the Dotkernel Headless Platform, sharing the same file structure and the same Core submodule used across the Dotkernel application suite (Frontend, API, Admin), ensuring consistency across the platform.
+- Dotkernel Queue is a standalone application in its own right, so it can be added more easily to an existing platform.
+- The implemented queue features are used in the team's own projects, so their worth is guaranteed in live projects.
 
-## Why Decouple Operations from the HTTP Request-Response?
+## Why Decouple Operations from the HTTP Request-Response Cycle?
 
-By default, the **PHP settings** impose a **maximum execution time** of 30 seconds via the `max_execution_time` parameter. You could extend the interval, but certainly not to hours or days for a simple request. Even that 30 second interval is unreasonably long in any website which normally expects a response in a few seconds or even under 1 second. The solution is to **delegate the execution** of those tasks to an outside system specifically designed for this purpose.
+By default, PHP settings impose a maximum execution time of 30 seconds via the `max_execution_time` parameter.
+Extending the interval isn't practical up to hours or days for a simple request, and even 30 seconds is unreasonably long for a website that normally expects a response in a few seconds or under 1 second.
+The solution is to delegate the execution of those tasks to an outside system specifically designed for this purpose.
 
 ## What Are Tasks with Long Execution?
 
-Normally, the tasks delegated to the queue:
+Tasks delegated to the queue typically:
 
 - Take extended periods of time to execute and may be interrupted by PHP limitations.
-- Are external calls which introduces delays from authentication, awaiting responses from potentially multiple interrogations, or may even fail completely because the 3rd party server is offline.
+- Are external calls that introduce delays from authentication, awaiting responses from potentially multiple interrogations, or may fail because the 3rd party server is offline.
 - Are not part of the main PHP request-response cycle.
 
-Many tasks can take an extended interval of time to finish execution:
-
-- **Data Processing** like big data analytics, scientific simulations, or mathematical computations.
-- **File Handling & Media Processing** like video and image processing, or compression/decompression of large files.
-- **Networking** like sending email, newsletters, notifications using 3rd party providers.
-- **Database Operations** like imports/exports or migrations.
-- **System & Infrastructure Tasks** like OS updates, software compilation, CI pipelines.
+Categories of tasks that can take an extended time to finish:
 
-There are multiple reasons for the long execution times:
+- **Data Processing** - big data analytics, scientific simulations, or mathematical computations.
+- **File Handling & Media Processing** - video and image processing, or compression/decompression of large files.
+- **Networking** - sending email, newsletters, notifications using 3rd party providers.
+- **Database Operations** - imports/exports or migrations.
+- **System & Infrastructure Tasks** - OS updates, software compilation, CI pipelines.
 
-- Data size - gigabytes, terabytes etc.
-- Complex algorithms.
-- Hardware limitations - CPU speed, memory, storage, network bandwidth.
-- External dependencies - waiting on APIs or human input.
-
-The tasks listed above take a long time no matter how many gigahertz, gigabytes and gigaflops you throw at them. Even NASA computers need minutes to compute the launch window to put a rocket in orbit.
+Reasons for long execution times include: data size (gigabytes, terabytes, etc.), complex algorithms, hardware limitations (CPU speed, memory, storage, network bandwidth), and external dependencies (waiting on APIs or human input).
 
 ## How the Dotkernel Queue Works
 
-The queue system has an active **daemon** that listens for TPC connections on a specific port and **stores incoming messages** into Redis. This method supports a large number of requests per second without overloading. Operations are then scheduled for execution when resources are available. The order of the execution uses the **FIFO** (First-In, First-Out) method where the oldest request is processed first, followed by newer requests.
+The queue system has an active daemon that listens for TCP connections on a specific port and stores incoming messages into Redis.
+This supports a large number of requests per second without overloading.
+Operations are then scheduled for execution when resources are available, using the FIFO (First-In, First-Out) method, where the oldest request is processed first, followed by newer requests.
 
 ![](/uploads/article/019f8a80-cc97-70d1-a431-cb612f641c19/Queue-process2.png)
 
 ## Main Features
 
-We feel that a queue would be incomplete without at least these features. Several more features are in the works or scheduled for the future - we will discuss these in the next segment. We are using this queuing component in our live projects, so every feature has been tried and tested extensively in production before making it in this open-source version of Dotkernel Queue.
+The following features are already implemented and have been tried and tested extensively in the team's live projects.
 
 ### Logging
 
-Logging is a vital feature that allows developers to monitor operations in a platform and investigate issues. It can help pinpoint the cause of an error which leads to faster bug fixes and less downtime.
-
-Detailed queue logs ensure the execution of long operations is maintainable and allows debugging. You must code your project-specific core logic to satisfy your business requirements.
+Logging allows developers to monitor operations and investigate issues, helping pinpoint the cause of an error for faster bug fixes and less downtime.
+Detailed queue logs ensure the execution of long operations is maintainable and allows debugging, though project-specific core logic must still be coded to satisfy business requirements.
 
 ### Security
 
-Access control is secured by the **firewall** which only allows requests from whitelisted IPs. This ensures that the queue responds as fast as possible, without delays from e.g. generating and authenticating dynamic tokens.
-
-Of course, a better security setup is to keep the Dotkernel Queue server accessible only via the internal network. In his case, you don't need the firewall, which simplifies the initial queue setup.
+Access control is secured by a firewall that only allows requests from whitelisted IPs, keeping the queue as fast as possible without delays from generating and authenticating dynamic tokens.
+A more secure setup is to keep the Dotkernel Queue server accessible only via the internal network, which removes the need for the firewall and simplifies initial queue setup.
 
 ### Retry Mechanism
 
-If message processing fails, the **internal retry feature** comes into play to guarantee reliable and stable execution. The system can be configured to retry failing tasks a certain number of times - while logging the cause - before giving up and reporting a failure in execution.
-
-After configuring the numer of retries for the queue, you are responsible for the additional handling of failed messages. In some cases, it makes sense to give up on retrying an operation from the first failure, e.g. if an email is invalid, it won't fix itself on the next try. Other times, the cause of the error is temporary, e.g. a database is overloaded, but the queries are valid, so they just need to run later.
+If message processing fails, an internal retry feature guarantees reliable and stable execution.
+The system can be configured to retry failing tasks a certain number of times, logging the cause each time, before giving up and reporting a failure.
+After configuring the number of retries, additional handling of failed messages is left to the developer: some failures (e.g. an invalid email address) won't fix themselves on retry, while others (e.g. a temporarily overloaded database with valid queries) just need to run later.
 
 ### Reporting
 
-The logs enable developers to investigate various metrics via console commands like:
+Logs enable developers to investigate metrics via console commands, including:
 
-- Queue length - How many jobs are in the to-do list.
+- Queue length - how many jobs are in the to-do list.
 - Processing time per job.
-- Error rates - How many messages failed.
-- Throughput - Jobs/sec processed.
+- Error rates - how many messages failed.
+- Throughput - jobs/sec processed.
 
 ### Dead Letter Queue (DLQ)
 
-A **Dead-Letter Queue** is a separate message queue that **temporarily stores messages that failed execution** due to errors. The reason for the errors can vary from having incomplete messages, to the 3rd party receiver not being able to process the request or not being available at all (being unresponsive).
-
-Certain errors may move the messages into the DLQ on the first try which ensures that the main queue is not overflowing with or outright blocked by messages that will never be processed in their current state. At the same time, it provides troubleshooters a central location to help identify the causes for errors. The queue will allow troubleshooters to apply fixes, then either manually push the messages back into the main queue, or delete them altogether.
+A Dead-Letter Queue is a separate message queue that temporarily stores messages that failed execution due to errors - for example, incomplete messages, or a 3rd party receiver unable to process the request or unavailable.
+Certain errors may move messages into the DLQ on the first try, keeping the main queue from being overwhelmed or blocked by messages that will never be processed in their current state.
+It also gives troubleshooters a central location to identify causes of errors, apply fixes, and then either manually push the messages back into the main queue or delete them.
 
 ## Future Features
 
-We are looking into ways to improve Dotkernel Queue and add new features as they are needed in the field.
+Ways to improve Dotkernel Queue are being explored, with new features added as needed in the field.
 
 ### Priorities
 
-Currently, the queue system works on the FIFO method, like we mentioned before. **Priorities** determine how soon a task is to begin execution - immediately or delayed. Certain tasks may be fast enough that they can be handled as they come in, while other tasks are purposefully pushed further down the line. Priorities are **set to be integrated** into Dotkernel Queue in the near future.
+Currently the queue works on the FIFO method described above.
+Priorities would determine how soon a task begins execution - immediately or delayed - since certain tasks may be fast enough to handle as they come in, while others are purposefully pushed further down the line.
+Priorities are set to be integrated into Dotkernel Queue in the near future.
 
 ### Parallel Execution
 
-**Execution** is made for each task, **one at a time**. We are investigating **parallel execution** of operations via multiple workers, where applicable. For example, preprocessing a report may be executed in parallel with sending emails because they are separate systems (email processing is external, while the report uses data from the internal database).
-
-## Additional Resources
-
-- [Dotkernel Queue Documentation](https://docs.dotkernel.org/queue-documentation/v1/overview/)
-- [Dotkernel Repository](https://github.com/dotkernel/)
-- [Symfony Messenger Documentation](https://symfony.com/doc/current/messenger.html)
-- [Symfony Messenger systemd](https://jolicode.com/blog/symfony-messenger-systemd)
-- [How To Prioritize Messages When Building Asynchronous Applications With Symfony Messenger](https://sensiolabs.com/blog/2025/how-to-prioritize-messages-when-building-asynchronous-applications-with-symfony-messenger)
+Execution is currently made for each task one at a time.
+Parallel execution of operations via multiple workers is being investigated, where applicable - for example, preprocessing a report could run in parallel with sending emails, since they are separate systems (email processing is external, while the report uses data from the internal database).
 
 ## FAQ
 
 **Q: What is Dotkernel Queue?**
-A: Dotkernel Queue is a component based on Symfony Messenger used to queue asynchronous tasks. It uses the netglue/laminas-messenger adapter to integrate Symfony Messenger with the Laminas Service Manager container for Mezzio/Laminas applications.
+A: Dotkernel Queue is a component based on Symfony Messenger used to queue asynchronous tasks.
+It uses the netglue/laminas-messenger adapter to integrate Symfony Messenger with the Laminas Service Manager container for Mezzio/Laminas applications.
 
 **Q: Why use Dotkernel Queue instead of using Symfony Messenger directly?**
 A: Dotkernel Queue builds on Symfony Messenger's mechanisms so it stays updated as Symfony Messenger evolves, uses netglue/laminas-messenger to work as Mezzio/Laminas-compatible middleware, shares the same file structure and Core submodule as the Dotkernel Headless Platform for seamless compatibility, works as a standalone application that can be added to an existing platform, and includes features already tried and tested in the team's own live projects.
@@ -135,10 +132,24 @@ A: Dotkernel Queue builds on Symfony Messenger's mechanisms so it stays updated
 A: By default, PHP imposes a maximum execution time of 30 seconds via the max_execution_time parameter, which is too long for a typical request. Instead of extending that limit, the solution is to delegate such tasks to an outside system designed for this purpose, so the main platform can return a response quickly and stay responsive to new requests.
 
 **Q: How does the Dotkernel Queue process messages?**
-A: An active daemon listens for TCP connections on a specific port and stores incoming messages into Redis, which supports a large number of requests per second without overloading. Messages are then scheduled for execution using the FIFO (First-In, First-Out) method, so the oldest request is processed first.
+A: An active daemon listens for TCP connections on a specific port and stores incoming messages into Redis, which supports a large number of requests per second without overloading.
+Messages are then scheduled for execution using the FIFO (First-In, First-Out) method, so the oldest request is processed first.
 
 **Q: What happens when a queued message fails to process?**
-A: A configurable retry mechanism retries failing tasks a set number of times, while logging the cause, before giving up and reporting a failure. Messages that ultimately fail can be moved into a Dead Letter Queue, a separate store for failed messages, where troubleshooters can identify the cause, apply a fix, and either push the message back into the main queue or delete it.
+A: A configurable retry mechanism retries failing tasks a set number of times, while logging the cause, before giving up and reporting a failure.
+Messages that ultimately fail can be moved into a Dead Letter Queue, a separate store for failed messages, where troubleshooters can identify the cause, apply a fix, and either push the message back into the main queue or delete it.
 
 **Q: What features is Dotkernel Queue planning to add in the future?**
 A: Two features are being investigated: Priorities, which would let tasks begin execution sooner or later instead of strictly following FIFO order, and Parallel Execution, which would let independent operations run at the same time via multiple workers, such as preprocessing a report in parallel with sending emails.
+
+## Resources
+
+- [Dotkernel Queue Documentation](https://docs.dotkernel.org/queue-documentation/v1/overview/)
+- [Dotkernel Repository](https://github.com/dotkernel/)
+- [Symfony Messenger Documentation](https://symfony.com/doc/current/messenger.html)
+- [Symfony Messenger systemd](https://jolicode.com/blog/symfony-messenger-systemd)
+- [How To Prioritize Messages When Building Asynchronous Applications With Symfony Messenger](https://sensiolabs.com/blog/2025/how-to-prioritize-messages-when-building-asynchronous-applications-with-symfony-messenger)
+- [Dotkernel Queue on GitHub](https://github.com/dotkernel/queue)
+- [Symfony Messenger on GitHub](https://github.com/symfony/messenger)
+- [netglue/laminas-messenger on GitHub](https://github.com/netglue/laminas-messenger)
+- [Laminas Service Manager Documentation](https://docs.laminas.dev/laminas-servicemanager/)
diff --git a/public/md-articles/headless-platform/dotmaker-generate-common-code-in-dotkernel.md b/public/md-articles/headless-platform/dotmaker-generate-common-code-in-dotkernel.md
index c51b3e81..db026bf2 100644
--- a/public/md-articles/headless-platform/dotmaker-generate-common-code-in-dotkernel.md
+++ b/public/md-articles/headless-platform/dotmaker-generate-common-code-in-dotkernel.md
@@ -11,20 +11,24 @@ language: "en"
 # DotMaker - Generate common code in Dotkernel
 
 ## TL;DR
+
 DotMaker (`dotkernel/dot-maker`) programmatically generates project files and directories matching the Dotkernel file structure inspired by Mezzio.
 It boosts productivity and enforces consistency and standardization compared to creating modules and files by hand, and it can tell the difference between Dotkernel applications (Api, Admin, Frontend) to create the files each one requires.
 
-The `dotkernel/dot-maker` library, also named DotMaker, is designed to **programmatically generate project files and directories** that match the Dotkernel file structure inspired by Mezzio.
+https://www.youtube.com/watch?v=CPDilXP2kAc
 
-Handling the file creation and configuration task manually invites mistakes that nobody has time for. Enter DotMaker which provides a big **productivity boost** compared to doing everything manually by promoting **consistenty and standardization** for these common tasks.
+## Why use dot-maker?
 
-DotMaker is inspired by [Symfony Maker Bundle](https://github.com/symfony/maker-bundle) in terms of functionality. Mezzio has its own [CLI Tooling](https://docs.mezzio.dev/mezzio/v3/reference/cli-tooling/) that performs similar actions, while DotMaker has a more opinionated naming pattern and is designed specifically for Dotkernel applications.
+Creating a new module manually requires a relatively large number of files and folders.
+Doing this by hand leaves too many opportunities for mistakes that generate errors and delay development.
+DotMaker was built to handle this heavy lifting.
 
-https://www.youtube.com/watch?v=CPDilXP2kAc
+DotMaker is inspired by the [Symfony Maker Bundle](https://github.com/symfony/maker-bundle) in terms of functionality.
+Mezzio has its own [CLI Tooling](https://docs.mezzio.dev/mezzio/v3/reference/cli-tooling/) that performs similar actions, but DotMaker uses a more opinionated naming pattern and is designed specifically for Dotkernel applications.
 
-## The File Structure for a Module
+## The file structure for a module
 
-Below is an example of the file structure for a `Book` module and the related files it uses from the `Core` module.
+Example file structure for a `Book` module and the related files it uses from the `Core` module:
 
 ```
 .
@@ -59,51 +63,48 @@ Below is an example of the file structure for a `Book` module and the related fi
                     └── ConfigProvider.php
 ```
 
-> The example above is for a Dotkernel API project. This means that it has a Collection item, but is missing Form and template files that Dotkernel Admin requires. DotMaker can tell the difference between Dotkernel applications and will create the required files for each.
-
-## Why Use dot-maker?
+This example is for a Dotkernel API project, so it has a Collection but is missing the Form and template files that Dotkernel Admin requires.
+DotMaker can tell the difference between Dotkernel applications and will create the required files for each.
 
-Even this simple example showcases the relatively **large number of files and folders** needed to make a new module work. A developer can perform the task **manually**, but there are too many places where things can be left out which **generate errors and delay development**. The **solution** is to use DotMaker which was built to help with the heavy lifting here.
+## How dot-maker works
 
-## How dot-maker Works
+To create a new module:
 
-Let's say you want to **create a new module** in your application:
+1. Run `./vendor/bin/dot-maker module`.
+2. Follow the prompted list of steps that create each relevant item, from entities and repositories to handlers and services.
+3. DotMaker automatically creates the module's `ConfigProvider.php` and tells you how to register it in `config/config.php` and `composer.json`.
+4. DotMaker generates documentation in an `OpenApi.php` file and tells you what command to run to generate migrations for the new module.
+5. Once the files are created, manually configure the authorization for the new module based on the platform's requirements.
 
-- After you enter the command `./vendor/bin/dot-maker module`, you are **prompted to go through a list of steps** that **create each item** relevant to your module, from entities and repositories, to handlers and services.
-- DotMaker automatically creates the `ConfigProvider.php` that is vital for **configuring your module** and tells you how to **register** it in `config/config.php` and `composer.json`.
-- The library also generates **documentation** in `OpenApi.php` file and tells you what command to run to generate **migrations** for your new module.
-- Once the files are created, you should **manually configure the authorization** for the new module based on your platform's requirements.
+Authorization is configured in different files between Dotkernel applications:
 
-> Authorization is configured in different files between Dotkernel applications:
-> 
-> - Dotkernel Api uses `config/autoload/authorization.global.php`. You can check [Api authorization](https://docs.dotkernel.org/api-documentation/v6/core-features/authorization/) for details.
-> - Dotkernel Admin and Dotkernel Frontend use `config/autoload/authorization-guards.global.php`. Here are the links for [Admin authorization](https://docs.dotkernel.org/admin-documentation/v6/how-to/authorization/) and [Frontend authorization](https://docs.dotkernel.org/frontend-documentation/v5/how-to/authorization/).
+| Application | Authorization file |
+|---|---|
+| Dotkernel Api | `config/autoload/authorization.global.php` ([docs](https://docs.dotkernel.org/api-documentation/v6/core-features/authorization/)) |
+| Dotkernel Admin | `config/autoload/authorization-guards.global.php` ([docs](https://docs.dotkernel.org/admin-documentation/v6/how-to/authorization/)) |
+| Dotkernel Frontend | `config/autoload/authorization-guards.global.php` ([docs](https://docs.dotkernel.org/frontend-documentation/v5/how-to/authorization/)) |
 
-DotMaker can also create **individual items** related to a module, like an entity or a form, as well as a new command or middleware. Below if a list of the available commands. Most of them are aimed at creating an item within existing modules, excepting the one that handles module creation, of course.
+### Generating individual items
 
-> The commands below work only after the basic command is added to `composer.json`.
+DotMaker can also create individual items related to a module, like an entity, a form, a new command, or a middleware, instead of a whole module.
+These commands work only after the basic command is added to `composer.json`.
 
-- `composer make collection` or `./vendor/bin/dot-maker collection` creates a Collection for an existing module.
-- `composer make command` or `./vendor/bin/dot-maker command` creates a Command for an existing module.
-- `composer make entity` or `./vendor/bin/dot-maker entity` creates an Entity and its associated Repository (e.g. `Entity\Phone.php` and `Repository\PhoneRepository.php`) for an existing module. If the Repository is already created, dot-maker will skip its creation and will return a message stating that it exists.
-- `composer make form` or `./vendor/bin/dot-maker form` creates a Form for an existing module.
-- `composer make handler` or `./vendor/bin/dot-maker handler` creates a Handler for an existing module.
-- `composer make input` or `./vendor/bin/dot-maker input` creates an Input for an existing module.
-- `composer make input-filter` or `./vendor/bin/dot-maker input-filter` creates an InputFilter for an existing module. You will be prompted to choose between 3 types of InputFilters: create, edit, replace.
-- `composer make middleware` or `./vendor/bin/dot-maker middleware` creates a Middleware for an existing module.
-- `composer make module` or `./vendor/bin/dot-maker module` creates a Module and its predefined files like entity, repository, service, handler etc.
-- `composer make repository` or `./vendor/bin/dot-maker repository` creates a Repository and its Entity (e.g. `Entity\Phone.php` and `Repository\PhoneRepository.php`) for an existing module. If the Entity is already created, dot-maker will skip its creation and will return a message stating that it exists.
-- `composer make service` or `./vendor/bin/dot-maker service` creates a Service and its associated ServiceInterface (e.g. `Service\PhoneService.php` and `Service\PhoneServiceInterface.php`) for an existing module. If the ServiceInterface is already created, dot-maker will skip its creation and will return a message stating that it exists.
-- `composer make service-interface` or `./vendor/bin/dot-maker service-interface` creates a ServiceInterface and its associated Service (e.g. `Service\PhoneServiceInterface.php` and `Service\PhoneService.php`) for an existing module. If the Service is already created, dot-maker will skip its creation and will return a message stating that it exists.
+| Command | Effect |
+|---|---|
+| `composer make collection` / `./vendor/bin/dot-maker collection` | Creates a Collection for an existing module |
+| `composer make command` / `./vendor/bin/dot-maker command` | Creates a Command for an existing module |
+| `composer make entity` / `./vendor/bin/dot-maker entity` | Creates an Entity and its associated Repository (skips the Repository if it already exists) |
+| `composer make form` / `./vendor/bin/dot-maker form` | Creates a Form for an existing module |
+| `composer make handler` / `./vendor/bin/dot-maker handler` | Creates a Handler for an existing module |
+| `composer make input` / `./vendor/bin/dot-maker input` | Creates an Input for an existing module |
+| `composer make input-filter` / `./vendor/bin/dot-maker input-filter` | Creates an InputFilter for an existing module (prompts for create, edit, or replace type) |
+| `composer make middleware` / `./vendor/bin/dot-maker middleware` | Creates a Middleware for an existing module |
+| `composer make module` / `./vendor/bin/dot-maker module` | Creates a Module and its predefined files (entity, repository, service, handler, etc.) |
+| `composer make repository` / `./vendor/bin/dot-maker repository` | Creates a Repository and its Entity (skips the Entity if it already exists) |
+| `composer make service` / `./vendor/bin/dot-maker service` | Creates a Service and its associated ServiceInterface (skips the ServiceInterface if it already exists) |
+| `composer make service-interface` / `./vendor/bin/dot-maker service-interface` | Creates a ServiceInterface and its associated Service (skips the Service if it already exists) |
 
-This tool won't do all the work for you, but after running through the maker process, you know you are **working on a solid foundation that can now accept your custom code**.
-
-## Additional Resources
-
-- [DotMaker full documentation](https://docs.dotkernel.org/dot-maker/v1/overview/)
-- [Implementing a book module in Dotkernel API using DotMaker](https://docs.dotkernel.org/api-documentation/v6/tutorials/create-book-module-via-dot-maker/)
-- [API file structure](https://docs.dotkernel.org/api-documentation/v6/introduction/file-structure/)
-- [Symfony Maker Bundle Documentation](https://symfony.com/bundles/SymfonyMakerBundle/current/index.html)
+DotMaker won't do all the work, but after running through the maker process you have a solid foundation ready to accept custom code.
 
 ## FAQ
 
@@ -111,16 +112,27 @@ This tool won't do all the work for you, but after running through the maker pro
 A: DotMaker (dotkernel/dot-maker) programmatically generates project files and directories that match the Dotkernel file structure inspired by Mezzio, giving a productivity boost and promoting consistency and standardization compared to creating everything manually.
 
 **Q: What inspired DotMaker and how is it different from Mezzio's own CLI tooling?**
-A: DotMaker is inspired by the Symfony Maker Bundle in terms of functionality. Mezzio has its own CLI Tooling that performs similar actions, but DotMaker uses a more opinionated naming pattern and is designed specifically for Dotkernel applications.
+A: DotMaker is inspired by the Symfony Maker Bundle in terms of functionality.
+Mezzio has its own CLI Tooling that performs similar actions, but DotMaker uses a more opinionated naming pattern and is designed specifically for Dotkernel applications.
 
 **Q: How do I create a new module with DotMaker?**
-A: Run ./vendor/bin/dot-maker module and follow the prompts that walk you through creating each relevant item, from entities and repositories to handlers and services. DotMaker also automatically creates the module's ConfigProvider.php, tells you how to register it in config/config.php and composer.json, generates documentation in an OpenApi.php file, and tells you what command to run to generate migrations.
+A: Run ./vendor/bin/dot-maker module and follow the prompts that walk you through creating each relevant item, from entities and repositories to handlers and services.
+DotMaker also automatically creates the module's ConfigProvider.php, tells you how to register it in config/config.php and composer.json, generates documentation in an OpenApi.php file, and tells you what command to run to generate migrations.
 
 **Q: Does DotMaker configure authorization for the new module?**
 A: No, authorization must be configured manually after the files are created, and the location differs between Dotkernel applications: Dotkernel Api uses config/autoload/authorization.global.php, while Dotkernel Admin and Dotkernel Frontend use config/autoload/authorization-guards.global.php.
 
 **Q: Can DotMaker generate individual items instead of a whole module?**
-A: Yes. DotMaker provides individual commands to create items such as a collection, command, entity, form, handler, input, input-filter, middleware, repository, service, or service-interface for an existing module. For example, ./vendor/bin/dot-maker entity creates an Entity and its associated Repository, skipping the Repository if it already exists.
+A: Yes.
+DotMaker provides individual commands to create items such as a collection, command, entity, form, handler, input, input-filter, middleware, repository, service, or service-interface for an existing module.
+For example, ./vendor/bin/dot-maker entity creates an Entity and its associated Repository, skipping the Repository if it already exists.
 
 **Q: Do the composer make shortcuts work right away?**
 A: No, commands like composer make entity only work after the basic command has been added to composer.json; the equivalent ./vendor/bin/dot-maker form is available regardless.
+
+## Resources
+
+- [DotMaker full documentation](https://docs.dotkernel.org/dot-maker/v1/overview/)
+- [Implementing a book module in Dotkernel API using DotMaker](https://docs.dotkernel.org/api-documentation/v6/tutorials/create-book-module-via-dot-maker/)
+- [API file structure](https://docs.dotkernel.org/api-documentation/v6/introduction/file-structure/)
+- [Symfony Maker Bundle Documentation](https://symfony.com/bundles/SymfonyMakerBundle/current/index.html)
diff --git a/public/md-articles/headless-platform/evolution-pattern-versus-api-versioning.md b/public/md-articles/headless-platform/evolution-pattern-versus-api-versioning.md
index edfdf9a4..65fd5018 100644
--- a/public/md-articles/headless-platform/evolution-pattern-versus-api-versioning.md
+++ b/public/md-articles/headless-platform/evolution-pattern-versus-api-versioning.md
@@ -11,48 +11,49 @@ language: "en"
 # Evolution Pattern versus API Versioning
 
 ## TL;DR
+
 An Evolution Pattern keeps the same codebase and evolves it gradually (for example via sunsetting), while API versioning maintains multiple parallel versions of an API so existing clients aren't broken.
 The two are not mutually exclusive.
 Dotkernel API favors an evolution pattern with a sunsetting mechanism, reserving full versioning for major, format-level changes.
 
-In programming and software architecture, an **Evolution Pattern** is a reusable, high-level strategy for modifying or evolving existing software systems over time. An evolution pattern tries to keep software relevant for old and new users by whatever means are available, as new needs arise.
-
-**Versioning** in software is the practice of assigning unique identifiers (version numbers) to different releases of a software platform. These numbers help track changes, improvements, bug fixes, compatibility, and evolution over time. In particular, API versioning is the practice of assigning versions to an API so that it can change over time without breaking existing clients that rely on it.
-
-## When to Use Evolution Pattern versus Versioning
+## Definitions
 
-Technically, the two concepts are not in conflict:
+- **Evolution Pattern**: A reusable, high-level strategy for modifying or evolving existing software systems over time, keeping software relevant for old and new users as new needs arise.
+- **Versioning**: The practice of assigning unique version numbers to different releases of a software platform to track changes, improvements, bug fixes, compatibility, and evolution.
+API versioning specifically assigns versions to an API so it can change without breaking existing clients.
+- **Sunsetting**: A mechanism for announcing that an API's old functionality will be phased out on a given date, via response headers, documentation, and public announcements.
 
-- An evolution pattern keeps the same codebase and announces compatibility breaking updates via mechanisms like sunsetting which we will discuss later on.
-- API versioning focuses on maintaining multiple versions of an API so changes do not affect users that implemented older versions.
+## When to use an Evolution Pattern versus Versioning
 
-You can very well have a platform employ both strategies, if it suits your needs.
+Technically, the two concepts are not in conflict - an evolution pattern keeps the same codebase and announces breaking changes via mechanisms like sunsetting, while API versioning maintains multiple versions of an API so that changes don't affect clients using older versions.
+A platform can use both strategies together if it suits its needs. The responsibility falls on the team to decide where to invest development and maintenance costs.
 
 | Problem | Potential Solution | Strategy |
-| --- | --- | --- |
-| Fix a typo in the parameter name | Sunsetting / Do nothing (it's only a typo) | Evolution pattern. Versioning is overkill. |
+|---|---|---|
+| Fix a typo in the parameter name | Sunsetting / do nothing (it's only a typo) | Evolution pattern. Versioning is overkill. |
 | Add a new parameter | Make it optional, so it doesn't break existing implementations | Evolution pattern |
-| Implement a BC breaking update that clients must adhere to | Announce it in time to allow your clients to adapt | Evolution pattern |
-| Implement a major update to an endpoint | Add a `v2` for only that endpoint, not the whole API, and encourage clients to migrate to v2 | Evolution pattern + Versioning |
+| Implement a backward-compatibility-breaking update that clients must adhere to | Announce it in time to allow clients to adapt | Evolution pattern |
+| Implement a major update to an endpoint | Add a `v2` for only that endpoint, not the whole API, and encourage clients to migrate | Evolution pattern + Versioning |
 | Return responses in a totally different format (e.g. GraphQL vs REST APIs) | Keep both versions active | Versioning |
 
-The responsiblity is yours to decide if the costs for development and maintenance are better aimed at one strategy over the other.
+## Practical example from Dotkernel API
 
-## Practical Example from Dotkernel API
+Dotkernel avoids full rewrites, considering them too risky, costly, and often not the best solution.
+Software evolution should instead be gradual and organic, adapting to new requirements with as little impact to the codebase and clients as possible.
 
-We try to stay away from full rewrites. They are too risky, costly, and often times simply not the best solution. Software evolution should be gradual and organic, with the purpose of adapting to new requirements with as little impact to the codebase and clients as possible.
+For Dotkernel API, an evolution pattern with a sunsetting mechanism was chosen: the codebase stays the same, and new requirements are implemented in a targeted manner.
 
-For our Dotkernel API, we chose an evolution pattern that takes advantage of a sunsetting mechanism. The codebase remains the same, with new requirements being implemented in a targeted manner.
+To enhance an endpoint, Dotkernel distinguishes between calls based on their payload.
+For example, on the `/user` endpoint:
 
-If we are required to enhance an endpoint, one solution we employ is to distinguish between two calls based on their payload. For example, if the 3rd-party frontend calls our `/user` endpoint:
+- A request with only an `email` uses the older functionality and returns the response currently working for existing clients.
+- A request with both `email` and `name` returns an enhanced response, requiring clients to update their own code to handle the new response structure.
 
-- With only an `email`, we use the older functionality and return the response that is currently working for clients.
-- With an `email and a name`, we return an enhanced response. This requires clients to update their own code to handle the new structure of the API response.
+### Announcing deprecation
 
-We announce endpoint deprecation by including an updated response header via handler attributes.
+Deprecation is announced by including an updated response header via handler attributes, with customizable values for `sunset`, `link`, and `deprecationReason`.
 
-```
-...
+```php
 #[ResourceDeprecation(
     sunset: '2026-01-01',
     link: 'https://docs.dotkernel.org/api-documentation/v7/tutorials/api-evolution/',
@@ -65,7 +66,7 @@ class OldHandler implements RequestHandlerInterface
 ...
 ```
 
-The values for `sunset`, `link` and `deprecationReason` above are customizable. By including this attribute, the reponse for the edited endpoint looks similar to the below.
+A deprecated endpoint's response includes headers similar to:
 
 ```
 HTTP/1.1 200 OK
@@ -80,45 +81,53 @@ Link: https://docs.dotkernel.org/api-documentation/v7/tutorials/api-evolution/;r
 Vary: Origin
 ```
 
-This header must be read and understood by developers who can then plan an update for their own software before the sunsetting date. The new functionality is normally kept in place alongside the old one for a reasonable amount of time. When the sunset date is reached, the old functionality is removed and only the new one is left in production:
+Developers must read and understand this header so they can plan an update before the sunset date.
+New functionality is normally kept alongside the old functionality for a reasonable period.
+Once the sunset date is reached, the old functionality is removed and only the new one remains in production:
 
-- An endpoint would return `404 Not Found`.
-- A property would be removed from the response.
+- An endpoint may return `404 Not Found`.
+- A property may be removed from the response.
 
-We use multiple channels to announce impactful, backward-incompatible updates for Dotkernel API:
+Dotkernel uses multiple channels to announce impactful, backward-incompatible updates:
 
 - **API headers** include the deprecation header.
 - **Documentation pages** detail the change and recommended code updates.
-- Announcements in the **public portal**, like articles and newsletters, are added to our blog.
+- **Public portal** announcements, like blog articles and newsletters.
 
-You should send out notifications early enough for them to reach the developers of 3rd-party software that use your API. This way they can plan and implement the update to ensure that their platforms have little or no downtime.
+Notifications should go out early enough to reach developers of third-party software using the API, so they can plan and implement updates with little or no downtime.
 
 ## Conclusions
 
-An evolution pattern requires good planning, which includes allocating enough time for your clients to be aware of your updates and to implement them in their own platforms. Ideally, there should be no downtime for either your, or your clients' platforms.
-
-Though we see it as avoidable in most real-life cases, versioning is still a valid strategy. We strongly believe it should be reserved for impactful architectural changes, as it's not suited for smaller changes like fixing typos in a parameter name or adding a new field.
-
-The strategies discussed in this article are not exhaustive, because ultimately you have to decide what approach works best for your use case.
-
-## Additional Resources
-
-- [What is the HTTP `Sunset` header?](https://sophiabits.com/blog/what-is-the-http-sunset-header)
-- [Deprecating Resources and Properties](https://api-platform.com/docs/core/deprecations)
-- [API Evolution for REST/HTTP APIs](https://philsturgeon.com/api-evolution-for-rest-http-apis)
-- [Just say no - to versioning APIs](https://www.hmeid.com/blog/just-say-no-to-versioning)
-- [Ways to version your API, Part 2](https://urthen.github.io/2013/05/16/ways-to-version-your-api-part-2)
+An evolution pattern requires good planning, including allocating enough time for clients to be aware of updates and implement them, ideally with no downtime for either side.
+Versioning remains a valid strategy but is best reserved for impactful architectural changes rather than smaller changes like fixing a typo or adding a field.
+Ultimately, the best approach depends on the specific use case.
 
 ## FAQ
 
 **Q: What is the difference between an Evolution Pattern and API versioning?**
-A: An Evolution Pattern is a reusable, high-level strategy for modifying or evolving existing software systems over time while keeping the same codebase, often using mechanisms like sunsetting. API versioning instead maintains multiple versions of an API so that changes do not affect clients relying on older versions. The two concepts are not in conflict, and a platform can use both strategies if it suits its needs.
+A: An Evolution Pattern is a reusable, high-level strategy for modifying or evolving existing software systems over time while keeping the same codebase, often using mechanisms like sunsetting.
+API versioning instead maintains multiple versions of an API so that changes do not affect clients relying on older versions.
+The two concepts are not in conflict, and a platform can use both strategies if it suits its needs.
 
 **Q: When should you use an evolution pattern instead of versioning?**
-A: Small changes, like fixing a typo in a parameter name or adding a new optional parameter, are best handled with an evolution pattern, since versioning would be overkill. Backward-compatible-breaking updates should be announced in time via an evolution pattern. A major update to a single endpoint can combine an evolution pattern with versioning, for example by adding a v2 for just that endpoint. Only when responses need to be returned in a totally different format, such as GraphQL versus REST, is versioning the better fit.
+A: Small changes, like fixing a typo in a parameter name or adding a new optional parameter, are best handled with an evolution pattern, since versioning would be overkill.
+Backward-compatible-breaking updates should be announced in time via an evolution pattern.
+A major update to a single endpoint can combine an evolution pattern with versioning, for example by adding a v2 for just that endpoint.
+Only when responses need to be returned in a totally different format, such as GraphQL versus REST, is versioning the better fit.
 
 **Q: How does Dotkernel API announce endpoint deprecations?**
-A: Dotkernel API distinguishes calls based on payload (for example, an older response for a request with only an email, versus an enhanced response when both email and name are supplied). Deprecation is announced by including an updated response header via handler attributes, with customizable values for sunset, link, and deprecationReason. These updates are also communicated through documentation pages and public portal channels like blog articles and newsletters.
+A: Dotkernel API distinguishes calls based on payload (for example, an older response for a request with only an email, versus an enhanced response when both email and name are supplied).
+Deprecation is announced by including an updated response header via handler attributes, with customizable values for sunset, link, and deprecationReason.
+These updates are also communicated through documentation pages and public portal channels like blog articles and newsletters.
 
 **Q: What happens once an endpoint's sunset date is reached?**
-A: The old functionality is removed and only the new functionality remains in production. In practice this means an endpoint may start returning 404 Not Found, or a property may be removed from the response.
+A: The old functionality is removed and only the new functionality remains in production.
+In practice this means an endpoint may start returning 404 Not Found, or a property may be removed from the response.
+
+## Resources
+
+- [What is the HTTP Sunset header?](https://sophiabits.com/blog/what-is-the-http-sunset-header)
+- [Deprecating Resources and Properties](https://api-platform.com/docs/core/deprecations)
+- [API Evolution for REST/HTTP APIs](https://philsturgeon.com/api-evolution-for-rest-http-apis)
+- [Just say no - to versioning APIs](https://www.hmeid.com/blog/just-say-no-to-versioning)
+- [Ways to version your API, Part 2](https://urthen.github.io/2013/05/16/ways-to-version-your-api-part-2)
diff --git a/public/md-articles/headless-platform/implementing-time-based-one-time-password-totp-in-dotkernel.md b/public/md-articles/headless-platform/implementing-time-based-one-time-password-totp-in-dotkernel.md
index 31d4710d..95c9a7ce 100644
--- a/public/md-articles/headless-platform/implementing-time-based-one-time-password-totp-in-dotkernel.md
+++ b/public/md-articles/headless-platform/implementing-time-based-one-time-password-totp-in-dotkernel.md
@@ -25,108 +25,125 @@ code_examples: "https://github.com/dotkernel/admin-documentation/tree/main/code_
 # Implementing Time-based One-Time Password (TOTP) in Dotkernel
 
 ## TL;DR
+
 `dot-totp` adds two-factor authentication (2FA) to Dotkernel Admin using time-based one-time passwords.
 Users authenticate with their password plus a 6-digit code from an Authenticator app that refreshes every 30 seconds.
 Installation is one Composer command plus a set of forms, handlers, middleware, and templates from the official code examples, applying a `TotpTrait` to the relevant entity, migrating three new database columns, and registering routes/pipeline/ConfigProvider updates.
 
-## What TOTP Does
+## Definitions
 
-A **Time-based One-Time Password (TOTP)** is a security algorithm used as part of **two-factor authentication (2FA)** to protect against account attacks. The mechanism is integrated into [dot-totp](https://github.com/dotkernel/dot-totp) to enhance security by requiring both a **password** and **an additional one-time code**. Our implementation follows the industry standard of using an Authenticator app to generate temporary, unique 6 digit codes that change every 30 seconds.
+- **TOTP (Time-based One-Time Password)**: A security algorithm used as part of two-factor authentication.
+Generates temporary, unique 6-digit codes that change every 30 seconds, via an Authenticator app.
+- **2FA (Two-Factor Authentication)**: Requires both a password and an additional one-time code, to protect against account attacks.
+- **dot-totp**: The Dotkernel package that integrates the TOTP mechanism into Dotkernel applications.
+- **Recovery codes**: Single-use backup codes generated during TOTP activation, usable for login when the mobile device is unavailable.
 
-In this article we will:
+## Key facts
 
-- Install `dot-totp` in [Dotkernel Admin](https://github.com/dotkernel/admin).
-- Review how `dot-totp` behaves in the UI.
+| Fact | Value |
+|---|---|
+| Package | `dotkernel/dot-totp` |
+| Install command | `composer require dotkernel/dot-totp` |
+| Target application | Dotkernel Admin (applies similarly to any middleware-based application) |
+| Code format | 6-digit numeric code |
+| Code lifetime | 30 seconds |
+| Recovery codes | Single-use each; must be saved in a secure location |
+| Entity integration | `TotpTrait` applied to any entity requiring 2FA |
+| New database columns | `totpSecret`, `totp_enabled`, `recovery_codes` |
+| Official tutorial | https://docs.dotkernel.org/admin-documentation/v7/tutorials/install-dot-totp/ |
+| Code examples | https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp |
 
-> You can also follow the installation steps in our [documentation site](https://docs.dotkernel.org/admin-documentation/v7/tutorials/install-dot-totp/).
+## 2FA with TOTP: authentication flow
 
-## 2FA with TOTP Flow
+1. User submits username and password (unchanged from standard login).
+2. Since TOTP is activated, the application also asks for the code from the user's Authenticator app.
+3. User submits the current 6-digit code, or alternatively a single-use recovery code.
+4. If the code is valid, the user is logged in.
 
 Below is a simplified flow for the 2FA with TOTP mechanism.
 
 ![](/uploads/article/019f8a80-cc99-7003-89fb-1a4493d92a4c/totp-flow.jpg)
 
-## How to Install dot-totp
-
-If you haven't already, install [Dotkernel Admin](https://github.com/dotkernel/admin).
+## Installation steps
 
-> These installation steps should work similarly in any middleware-based application.
+### Step 1 - Install the package
 
-The first step is to include the package into your project by running this command:
+Prerequisite: a working Dotkernel Admin installation.
 
-```
+```shell
 composer require dotkernel/dot-totp
 ```
 
-We will follow the Dotkernel file structure and create the files in the list below. If you follow the links from the [main totp integration example](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp), you can download the files and add them to your codebase.
+### Step 2 - Add the integration files
 
-- [src/Admin/src/Form/RecoveryForm.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Form/RecoveryForm.php)
-- [src/Admin/src/Form/TotpForm.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Form/TotpForm.php)
-- [src/Admin/src/Handler/Account/GetDisableTotpFormHandler.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/GetDisableTotpFormHandler.php)
-- [src/Admin/src/Handler/Account/GetEnableTotpFormHandler.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/GetEnableTotpFormHandler.php)
-- [src/Admin/src/Handler/Account/GetRecoveryFormHandler.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/GetRecoveryFormHandler.php)
-- [src/Admin/src/Handler/Account/GetTotpHandler.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/GetTotpHandler.php)
-- [src/Admin/src/Handler/Account/PostDisableTotpHandler.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/PostDisableTotpHandler.php)
-- [src/Admin/src/Handler/Account/PostEnableTotpHandler.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/PostEnableTotpHandler.php)
-- [src/Admin/src/Handler/Account/PostValidateRecoveryHandler.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/PostValidateRecoveryHandler.php)
-- [src/Admin/src/Handler/Account/PostValidateTotpHandler.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/PostValidateTotpHandler.php)
-- [src/Admin/templates/admin/recovery-form.html.twig](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/templates/admin/recovery-form.html.twig)
-- [src/App/src/Middleware/CancelUrlMiddleware.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/App/src/Middleware/CancelUrlMiddleware.php)
-- [src/App/src/Middleware/TotpMiddleware.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/App/src/Middleware/TotpMiddleware.php)
+Following the Dotkernel file structure, add the files below (downloadable from the [official code examples](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp)):
 
-You can use the trait at [src/Core/src/App/src/Entity/TotpTrait.php](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Core/src/App/src/Entity/TotpTrait.php) in any entity where you need 2FA.
+Forms:
+- [`src/Admin/src/Form/RecoveryForm.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Form/RecoveryForm.php)
+- [`src/Admin/src/Form/TotpForm.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Form/TotpForm.php)
 
-> Make sure to migrate the new columns `totpSecret`, `totp_enabled` and `recovery_codes` in your entity.
+Handlers (in `src/Admin/src/Handler/Account/`):
+- [`GetDisableTotpFormHandler.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/GetDisableTotpFormHandler.php)
+- [`GetEnableTotpFormHandler.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/GetEnableTotpFormHandler.php)
+- [`GetRecoveryFormHandler.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/GetRecoveryFormHandler.php)
+- [`GetTotpHandler.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/GetTotpHandler.php)
+- [`PostDisableTotpHandler.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/PostDisableTotpHandler.php)
+- [`PostEnableTotpHandler.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/PostEnableTotpHandler.php)
+- [`PostValidateRecoveryHandler.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/PostValidateRecoveryHandler.php)
+- [`PostValidateTotpHandler.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/src/Handler/Account/PostValidateTotpHandler.php)
 
-There are still some code snippets in the [_misc](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp) folder:
+Templates:
+- [`src/Admin/templates/admin/recovery-form.html.twig`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Admin/templates/admin/recovery-form.html.twig)
 
-- [The enable/disable 2FA button](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/_misc/totp-append-view-account.html.twig) should be used in the `view-account.html.twig` file or in a new page.
-- [The routes updates](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/_misc/totp-append-routes.php) must be added in the `src/Admin/src/RoutesDelegator.php` file.
-- [The pipeline updates](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/_misc/totp-append-Pipeline.php) must be added in the `config/pipeline.php` file after `$app->pipe(AuthMiddleware::class);`.
-- [The ConfigProvider updates](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/_misc/totp-append-ConfigProvider.php) must be added in the `src/Admin/src/ConfigProvider.php` file.
+Middleware:
+- [`src/App/src/Middleware/CancelUrlMiddleware.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/App/src/Middleware/CancelUrlMiddleware.php)
+- [`src/App/src/Middleware/TotpMiddleware.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/App/src/Middleware/TotpMiddleware.php)
 
-## dot-totp in Action
+### Step 3 - Apply the entity trait and migrate the database
 
-Once you have `dot-totp` implemented, you can activate the feature in your admin accounts. If you navigate to your profile from the top-right image in Dotkernel Admin, you should see this box.
+Apply the trait at [`src/Core/src/App/src/Entity/TotpTrait.php`](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/src/Core/src/App/src/Entity/TotpTrait.php) to any entity that requires 2FA, then migrate the new columns onto that entity's table: `totpSecret`, `totp_enabled`, and `recovery_codes`.
 
-![](/uploads/article/019f8a80-cc99-7003-89fb-1a4493d92a4c/profile-totp-deactivated.jpg)
+### Step 4 - Register the remaining snippets
 
-Simply click on 'Enable TOTP' to begin the activation process.
+The `_misc` folder in the code examples contains four required additions:
 
-> We blurred out the QR code and recovery codes for this tutorial. You will receive dynamically generated versions that will be fully visible to you.
+| Snippet | Destination |
+|---|---|
+| [Enable/disable 2FA button](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/_misc/totp-append-view-account.html.twig) (`totp-append-view-account.html.twig`) | `view-account.html.twig`, or a new page |
+| [Routes updates](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/_misc/totp-append-routes.php) (`totp-append-routes.php`) | `src/Admin/src/RoutesDelegator.php` |
+| [Pipeline updates](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/_misc/totp-append-Pipeline.php) (`totp-append-Pipeline.php`) | `config/pipeline.php`, after `$app->pipe(AuthMiddleware::class);` |
+| [ConfigProvider updates](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp/_misc/totp-append-ConfigProvider.php) (`totp-append-ConfigProvider.php`) | `src/Admin/src/ConfigProvider.php` |
 
-> You will need to have an Authenticator app installed on your mobile device.
+## Using TOTP in Dotkernel Admin (end-user flow)
 
-![](/uploads/article/019f8a80-cc99-7003-89fb-1a4493d92a4c/totp-activate-qr.jpg)
+### Enabling TOTP
 
-Follow the instructions on the screen:
+1. Navigate to the account profile (top-right image in Dotkernel Admin).
+A TOTP box with an "Enable TOTP" button is shown.
 
-- Scan the QR code with your mobile device.
-- Enter the 6-digit code it generates on your mobile device.
+![](/uploads/article/019f8a80-cc99-7003-89fb-1a4493d92a4c/profile-totp-deactivated.jpg)
 
-> The code refreshes every 30 seconds.
+2. Click "Enable TOTP".
+A QR code is displayed. An Authenticator app on a mobile device is required.
 
-The TOPT activation flow will list several recovery codes you can use if your mobile device isn't available.
+![](/uploads/article/019f8a80-cc99-7003-89fb-1a4493d92a4c/totp-activate-qr.jpg)
 
-![](/uploads/article/019f8a80-cc99-7003-89fb-1a4493d92a4c/totp-recovery-codes.jpg)
+3. Scan the QR code with the mobile device.
+4. Enter the 6-digit code generated by the Authenticator app. The code refreshes every 30 seconds.
+5. Save the recovery codes shown during activation in a secure location - each is usable only once.
 
-> Each recovery code is usable only once.
+![](/uploads/article/019f8a80-cc99-7003-89fb-1a4493d92a4c/totp-recovery-codes.jpg)
 
-> Save the recovery codes in a secure location.
+6. If the code is valid, the user is logged in and TOTP is activated for the account.
 
-If the code is valid, you will be logged in, and TOTP will be activated for your account.
+### Logging in with TOTP enabled
 
-Whenever you need to log into the account, you will start by entering your username and password, like before. Since TOTP is activated, you will need to also submit the code from your Authenticator app. Alternatively, you can submit a recovery code.
+1. Enter username and password as before.
+2. Submit the current code from the Authenticator app, or alternatively a recovery code.
 
 ![](/uploads/article/019f8a80-cc99-7003-89fb-1a4493d92a4c/totp-ask-code.jpg)
 
-That's it! You are now logged in securely.
-
-## Additional Resources
-
-- [dot-totp in GitHub](https://github.com/dotkernel/dot-totp)
-- [Dotkernel Admin in GitHub](https://github.com/dotkernel/admin)
-- [Dotkernel Documentation - Installing dot-totp into Dotkernel Admin](https://docs.dotkernel.org/admin-documentation/v7/tutorials/install-dot-totp/)
+3. On success, the user is logged in.
 
 ## FAQ
 
@@ -134,13 +151,22 @@ That's it! You are now logged in securely.
 A: A Time-based One-Time Password (TOTP) is a security algorithm used as part of two-factor authentication (2FA) that requires both a password and an additional one-time code generated by an Authenticator app. In Dotkernel, this is implemented through the dot-totp package.
 
 **Q: Can dot-totp be used outside of Dotkernel Admin?**
-A: Yes. Although this tutorial installs dot-totp in Dotkernel Admin, the installation steps work similarly in any middleware-based PHP application.
+A: Yes.
+Although this tutorial installs dot-totp in Dotkernel Admin, the installation steps work similarly in any middleware-based PHP application.
 
 **Q: What happens if I lose access to my authenticator app?**
-A: You can log in using one of the recovery codes generated when you activated TOTP. Each recovery code is usable only once, so make sure to save them in a secure location.
+A: You can log in using one of the recovery codes generated when you activated TOTP.
+Each recovery code is usable only once, so make sure to save them in a secure location.
 
 **Q: How often does the TOTP code change?**
 A: The code generated by your Authenticator app refreshes every 30 seconds.
 
 **Q: What database changes are required to support dot-totp?**
 A: You need to migrate three new columns onto the entity that uses the TotpTrait: totpSecret, totp_enabled, and recovery_codes.
+
+## Resources
+
+- [dot-totp on GitHub](https://github.com/dotkernel/dot-totp)
+- [Dotkernel Admin on GitHub](https://github.com/dotkernel/admin)
+- [Official tutorial - Installing dot-totp into Dotkernel Admin](https://docs.dotkernel.org/admin-documentation/v7/tutorials/install-dot-totp/)
+- [Complete code examples](https://github.com/dotkernel/admin-documentation/tree/main/code_examples/totp)
diff --git a/public/md-articles/headless-platform/shared-core-submodule-in-dotkernel-headless-platform.md b/public/md-articles/headless-platform/shared-core-submodule-in-dotkernel-headless-platform.md
index 91cb143b..7f0dbebb 100644
--- a/public/md-articles/headless-platform/shared-core-submodule-in-dotkernel-headless-platform.md
+++ b/public/md-articles/headless-platform/shared-core-submodule-in-dotkernel-headless-platform.md
@@ -11,51 +11,55 @@ language: "en"
 # Shared Core Submodule in Dotkernel Headless Platform
 
 ## TL;DR
+
 Dotkernel's Headless Platform is composed of Dotkernel API, Admin, and Queue, and can share a common Core submodule that holds the database entities and services used consistently across all of them.
 The article walks through creating the Core submodule with `git submodule add`, committing changes from within the Core folder, and initializing/updating it with `git submodule init` and `git submodule update`.
 Sharing a Core module brings design flexibility, scalability, and easier bugfixes and onboarding as the platform grows.
 
-**Dotkernel** has implemented a **Headless** solution made up of these applications:
+Dotkernel has implemented a Headless solution made up of these applications:
 
 - [Dotkernel API](https://github.com/dotkernel/api) - a REST API, the root of the platform.
 - [Dotkernel Admin](https://github.com/dotkernel/admin) - (optional) complementary backend management.
 - [Dotkernel Queue](https://github.com/dotkernel/queue) - (optional) queue management microservice.
 
-This is effectively a **Headless CMS** architecture where the **Dotkernel Admin** manages the data via the database. The same data is independently exposed by **Dotkernel API** and used by **Dotkernel Queue**.
-
-## What is the Core submodule?
+This is effectively a Headless CMS architecture where the Dotkernel Admin manages the data via the database.
+The same data is independently exposed by Dotkernel API and used by Dotkernel Queue.
 
-The Core submodule is a common codebase set up to be used by the applications you added to your project. It can just as well work for any project setup, e.g. two APIs, one Admin, 3 Frontends.
+## What Is the Core Submodule?
 
-By having a common module in your Dotkernel applications, you ensure that each of them uses entities and services in the same way. Thus, rather than making e.g. an update in each application's services, you only update the relevant service in the Core once and sync it in each application.
+The Core submodule is a common codebase set up to be used by the applications you added to your project.
+It can just as well work for any project setup, e.g. two APIs, one Admin, 3 Frontends.
+By having a common module in your Dotkernel applications, you ensure that each of them uses entities and services in the same way.
+Thus, rather than making e.g. an update in each application's services, you only update the relevant service in the Core once and sync it in each application.
 
-> The golden rule for the Core codebase is that it is the **only** place which manages the database entities.
-> 
-> As much as possible, all Doctrine entities must reside in **Core**.
-> 
+> The golden rule for the Core codebase is that it is the only place which manages the database entities.
+> As much as possible, all Doctrine entities must reside in Core.
 > The current location of the Core submodule is `src/Core`.
 
-## How do I create a Core submodule?
+## How Do I Create a Core Submodule?
 
 The full steps for creating a submodule are described in [Git Tools - Submodules](https://git-scm.com/book/en/v2/Git-Tools-Submodules).
 
 > There is already a Core module in some of the Dotkernel applications, but it works like any other module (App, Page or User). The Core modules are designed to be a starting point for the module's transformation into a Git submodule.
 
-First create a new Git repository that will contain the Core code. To create the submodule in an application, you need to have Git create the `.gitmodules` file in the root of the main repository by running the command below. Use the url from the new repository you just created instead of `<url>`:
+First create a new Git repository that will contain the Core code.
+To create the submodule in an application, you need to have Git create the `.gitmodules` file in the root of the main repository by running the command below.
+Use the url from the new repository you just created instead of `<url>`:
 
-```
+```bash
 git submodule add <url>
 ```
 
 > You can have multiple submodules, but for this article we will only create the Core submodule.
 
-The `.gitmodules` file maps the submodule and its corresponding local directory within the main project (e.g. src/Core). This allows Git to manage the submodule correctly, from cloning, to updating, to tracking its changes.
+The `.gitmodules` file maps the submodule and its corresponding local directory within the main project (e.g. src/Core).
+This allows Git to manage the submodule correctly, from cloning, to updating, to tracking its changes.
 
 > None of the Dotkernel applications have the `.gitmodules` file out of the box. Only after isolating the Core into a Git submodule and pushing it to a separate Git repository does it become available to be included into any Dotkernel application.
 
-From now on, any changes to the Core submodule must be commited from within the Core folder, like for any other Git repository, using these commands (simplified version, provided as an example):
+From now on, any changes to the Core submodule must be committed from within the Core folder, like for any other Git repository, using these commands (simplified version, provided as an example):
 
-```
+```bash
 cd <path/to/submodule>
 git add .
 git commit -m "comment"
@@ -64,14 +68,14 @@ git push
 
 Whenever you clone the project, you simply need to init and update the submodule with these commands:
 
-```
+```bash
 git submodule init
 git submodule update
 ```
 
 > Do not forget to delete the existing Core module before adding the submodule to other applications.
 
-## How do I use the Core submodule?
+## How Do I Use the Core Submodule?
 
 Once the shared Core submodule is separated and imported into each application, your platform will look something like this:
 
@@ -83,18 +87,20 @@ Once the shared Core submodule is separated and imported into each application,
 
 > Each box in the image is a different Git repository.
 
-Whenever work begins on a new feature or update, the devs should normally have the most recent Core in their development environment. So in total you have four code bases which will be kept in four separate repositories.
-
-The Dotkernel applications include various **entities** to get you started quickly. This is not a complete list, but it should help you understand what each application is aimed toward:
+Whenever work begins on a new feature or update, the devs should normally have the most recent Core in their development environment.
+So in total you have four code bases which will be kept in four separate repositories.
+The Dotkernel applications include various entities to get you started quickly.
+This is not a complete list, but it should help you understand what each application is aimed toward:
 
-- The **admin** has admins, admin logins and settings entities.
-- The **api** has both users and admins, as well as authentication entities.
+- The admin has admins, admin logins and settings entities.
+- The api has both users and admins, as well as authentication entities.
 
-There are already shared entities which are identical, so the best place for them is within the Core submodule. Whenever you create new shared code, you should add it in the Core submodule and make sure to keep it updated in all your applications.
+There are already shared entities which are identical, so the best place for them is within the Core submodule.
+Whenever you create new shared code, you should add it in the Core submodule and make sure to keep it updated in all your applications.
 
 > This does not mean that all new code should be in Core, as there are plenty of instances when certain functionality is designed to only be used by one application.
 
-## Why the Core submodule is effective
+## Why the Core Submodule Is Effective
 
 This design pattern ensures:
 
@@ -104,28 +110,29 @@ This design pattern ensures:
 - The ability to split the work to multiple developers.
 - Easier bugfixes and onboarding.
 
-As your platform expands, each new application connects to the Dotkernel Headless Platform via the central API which services everything the other applications require. This ensures consistency throughout your platform, while allowing any number of outside connections as requirements arise.
+As your platform expands, each new application connects to the Dotkernel Headless Platform via the central API which services everything the other applications require.
+This ensures consistency throughout your platform, while allowing any number of outside connections as requirements arise.
 
 ![](/uploads/article/019f8a80-cc95-70fa-bdb7-28854eb6d673/api-comms4-2.png)
 
-## Additional Resources
-
-- [Dotkernel Git Repositories](https://github.com/dotkernel)
-- [Core in Dotkernel Headless Platform](https://docs.dotkernel.org/headless-documentation/v1/core/introduction/)
-
 ## FAQ
 
 **Q: What is the Core submodule in Dotkernel's Headless Platform?**
 A: The Core submodule is a common codebase shared by the applications in your project (for example API, Admin and Queue). It ensures each application uses entities and services in the same way, so rather than updating each application separately, you update the relevant service in Core once and sync it across applications.
 
 **Q: What is the golden rule for the Core codebase?**
-A: The Core codebase is the only place which manages the database entities. As much as possible, all Doctrine entities must reside in Core, whose current location is src/Core.
+A: The Core codebase is the only place which manages the database entities. As much as possible, all Doctrine entities must reside in Core, whose current location is `src/Core`.
 
 **Q: How do I create a Core submodule?**
-A: First create a new Git repository to hold the Core code. Then, in the main application repository, run git submodule add <url> using that new repository's URL. This generates the .gitmodules file, which maps the submodule to a local directory such as src/Core. From then on, changes to Core must be committed from within the Core folder like any other Git repository.
+A: First create a new Git repository to hold the Core code. Then, in the main application repository, run `git submodule add <url>` using that new repository's URL. This generates the `.gitmodules` file, which maps the submodule to a local directory such as `src/Core`. From then on, changes to Core must be committed from within the Core folder like any other Git repository.
 
 **Q: How do I get the Core submodule when cloning a project?**
-A: Run git submodule init followed by git submodule update. Remember to delete the existing Core module before adding the submodule to other applications.
+A: Run `git submodule init` followed by `git submodule update`. Remember to delete the existing Core module before adding the submodule to other applications.
 
 **Q: Which entities live in Admin and API versus the shared Core?**
 A: The admin application includes admins, admin logins and settings entities, while the API includes both users and admins, as well as authentication entities. Entities that are identical across applications should instead be kept in the shared Core submodule and synced whenever they change.
+
+## Resources
+
+- [Dotkernel Git Repositories](https://github.com/dotkernel)
+- [Core in Dotkernel Headless Platform](https://docs.dotkernel.org/headless-documentation/v1/core/introduction/)
diff --git a/public/md-articles/headless-platform/version-7-adds-postgresql-native-uuid-and-php-8-5.md b/public/md-articles/headless-platform/version-7-adds-postgresql-native-uuid-and-php-8-5.md
index 0ce097bf..5b242e07 100644
--- a/public/md-articles/headless-platform/version-7-adds-postgresql-native-uuid-and-php-8-5.md
+++ b/public/md-articles/headless-platform/version-7-adds-postgresql-native-uuid-and-php-8-5.md
@@ -11,17 +11,20 @@ language: "en"
 # Version 7 adds PostgreSQL, Native UUID and PHP 8.5
 
 ## TL;DR
+
 Dotkernel API v7 adds support for native UUID v7, PostgreSQL, PHP 8.5 (8.4 for Admin), database table prefixes, and improved database configuration, while replacing the `binary` data type for `id` columns with `uuid`.
 It drops the Evolution pattern's Method Deprecation support and MySQL, since MySQL doesn't support the UUID data type.
 UUIDs are generated with the ramsey/uuid package, previously `uuid`-named table columns are now called `id`, and PostgreSQL or MariaDB v10.7+ is required for UUID support.
 
-The Dotkernel Headless Platform has seen new releases for both API and Admin. The Admin codebase has received an overall facelift, as well as updates to retain compatibility with API v7. The release for Dotkernel API v7 has several added features, as well as a few that are removed.
+The Dotkernel Headless Platform has seen new releases for both API and Admin.
+The Admin codebase has received an overall facelift, as well as updates to retain compatibility with API v7.
+The release for Dotkernel API v7 has several added features, as well as a few that are removed.
 
 New features are:
 
 - Support for `UUID` v7 using the native `UUID` data type.
 - Support for PostgreSQL.
-- Support for PHP 8.5 for API and Admin.
+- Support for PHP 8.5 for API and 8.4 for Admin.
 - Support for database table prefix (string prepended to the name of every table in a database).
 - Improved database configuration.
 - The replacement of the `binary` data type for `id` (index) columns, in favor of `uuid`.
@@ -33,7 +36,10 @@ And these are the features that have been removed:
 
 ## Support for UUID v7
 
-The most important change in v7 is the introduction of support for native UUID. We use the package [ramsey/uuid](https://github.com/ramsey/uuid) to generate the uuid and then store it in the database. In this way we have full control over the UUID version in use. This solution means you don't depend on extensions or a particular version of the database.
+The most important change in v7 is the introduction of support for native UUID.
+We use the package [ramsey/uuid](https://github.com/ramsey/uuid) to generate the uuid and then store it in the database.
+In this way we have full control over the UUID version in use.
+This solution means you don't depend on extensions or a particular version of the database.
 
 > To ensure you have support for the `UUID` data type, you must use PostgreSQL or MariaDB v11.4 or later.
 
@@ -41,7 +47,8 @@ This also brings along a less-impactful change that still deserves mentioning: t
 
 ## Database Configuration
 
-Based on new scenarios in our own projects, we decided to clarify the instructions regarding multiple database connections. With this update, these aspects should become more obvious:
+Based on new scenarios in our own projects, we decided to clarify the instructions regarding multiple database connections.
+With this update, these aspects should become more obvious:
 
 - Which database connection is the default.
 - How to switch to another database connection.
@@ -49,7 +56,7 @@ Based on new scenarios in our own projects, we decided to clarify the instructio
 ## FAQ
 
 **Q: What new features does Dotkernel API v7 introduce?**
-A: v7 adds support for UUID v7 using the native UUID data type, support for PostgreSQL, support for PHP 8.5, support for a database table prefix, improved database configuration, and replaces the binary data type for id (index) columns in favor of uuid.
+A: v7 adds support for UUID v7 using the native UUID data type, support for PostgreSQL, support for PHP 8.5 (API) and 8.4 (Admin), support for a database table prefix, improved database configuration, and replaces the binary data type for id (index) columns in favor of uuid.
 
 **Q: What features were removed in v7?**
 A: v7 removes the Evolution pattern's support for Method Deprecation, and drops support for MySQL, primarily because MySQL doesn't support UUID as a data type.
@@ -61,4 +68,4 @@ A: Dotkernel uses the ramsey/uuid package to generate the UUID before storing it
 A: You must use PostgreSQL or MariaDB v11.4 or later to have support for the UUID data type.
 
 **Q: What else changed alongside the move to native UUID?**
-A: Table columns previously named uuid have been renamed to id. The database configuration was also clarified so it's more obvious which connection is the default and how to switch to another database connection.
+A: Table columns previously named `uuid` have been renamed to `id`. The database configuration was also clarified so it's more obvious which connection is the default and how to switch to another database connection.
diff --git a/public/md-articles/how-to/cors-policy-setup-in-dotkernel-using-mezzio-cors.md b/public/md-articles/how-to/cors-policy-setup-in-dotkernel-using-mezzio-cors.md
index ef9bc448..76c5d44e 100644
--- a/public/md-articles/how-to/cors-policy-setup-in-dotkernel-using-mezzio-cors.md
+++ b/public/md-articles/how-to/cors-policy-setup-in-dotkernel-using-mezzio-cors.md
@@ -11,36 +11,34 @@ language: "en"
 # CORS policy setup in Dotkernel using mezzio-cors
 
 ## TL;DR
+
 This article explains how to fix the common "No 'Access-Control-Allow-Origin' header is present" browser error by installing and configuring the mezzio-cors package.
 It covers registering the package's ConfigProvider and middleware, then creating a CORS configuration file.
 The configuration supports a permissive mode, where any origin is allowed, and a restrictive mode, where only specific listed origins are allowed.
 It also shows how to verify each mode is working correctly.
 
-## CORS policy setup in Dotkernel using mezzio-cors
-
-## Error message
-
-> Access to fetch at *RESOURCE_URL* from origin *ORIGIN_URL* has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource.
-
-Most developers have encountered this error when interacting with APIs. In this article we will run through the steps required to fix it.
+## Error Message
 
-**Cross-Origin Resource Sharing** ([CORS](https://developer.mozilla.org/en-US/docs/Glossary/CORS)) is an [HTTP](https://developer.mozilla.org/en-US/docs/Glossary/HTTP)-header based mechanism that allows a server to indicate any other [origin](https://developer.mozilla.org/en-US/docs/Glossary/Origin)s (domain, scheme, or port) than its own from which a browser should permit loading of resources.
+> Access to fetch at RESOURCE_URL from origin ORIGIN_URL has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource.
 
-The library we are going to use is [Mezzio CORS](https://docs.mezzio.dev/mezzio-cors/) .
+Most developers have encountered this error when interacting with APIs.
+In this article we will run through the steps required to fix it.
+Cross-Origin Resource Sharing ([CORS](https://developer.mozilla.org/en-US/docs/Glossary/CORS)) is an [HTTP](https://developer.mozilla.org/en-US/docs/Glossary/HTTP)-header based mechanism that allows a server to indicate any other [origins](https://developer.mozilla.org/en-US/docs/Glossary/Origin) (domain, scheme, or port) than its own from which a browser should permit loading of resources.
+The library we are going to use is [Mezzio CORS](https://docs.mezzio.dev/mezzio-cors/).
 
 ## Setup
 
-### Install package Mezzio CORS
+### Install Package Mezzio CORS
 
-Run the following command in your application’s root directory:
+Run the following command in your application's root directory:
 
-```
+```bash
 composer require mezzio/mezzio-cors
 ```
 
 ### Register ConfigProvider
 
-Open your application’s **config/config.php** file and add the following lines to the `$aggregator` variable:
+Open your application's `config/config.php` file and add the following lines to the `$aggregator` variable:
 
 `Laminas\Diactoros\ConfigProvider::class,`
 
@@ -48,7 +46,7 @@ Open your application’s **config/config.php** file and add the following lin
 
 ### Register Middleware
 
-Open your application’s **config/pipeline.php** file and add the following line (preferrably between *ErrorHandlerInterface::class* and the handler/middleware that will return your response):
+Open your application's `config/pipeline.php` file and add the following line (preferably between `ErrorHandlerInterface::class` and the handler/middleware that will return your response):
 
 `$app->pipe(CorsMiddleware::class);`
 
@@ -56,11 +54,11 @@ Don't forget to add the corresponding use at the top of the file:
 
 `use Mezzio\Cors\Middleware\CorsMiddleware;`
 
-### Create config file
+### Create Config File
 
-Create and open file **config/autoload/cors.local.php** and add the following code inside it:
+Create and open the file `config/autoload/cors.local.php` and add the following code inside it:
 
-```
+```php
 <?php
 
 declare(strict_types=1);
@@ -80,24 +78,23 @@ return [
 ];
 ```
 
-Note the value `ConfigurationInterface::ANY_ORIGIN` stored under `allowed_origins`. Leaving this value as is, makes your application accessible by any origin (*permissive mode*). To restrict access, replace it with a list of origins that should have access to your application (*restrictive mode*), for example:
+Note the value `ConfigurationInterface::ANY_ORIGIN` stored under `allowed_origins`.
+Leaving this value as is makes your application accessible by any origin (permissive mode).
+To restrict access, replace it with a list of origins that should have access to your application (restrictive mode), for example:
 
-```
-'allowed_origins' => [
-    "domain1.com", "domain2.com"
-],
+```php
+'allowed_origins' => ['https://example.com'],
 ```
 
-Don't forget to make a *distributable* version of you **config/autoload/cors.local.php** and add that to your repository.
+Don't forget to make a distributable version of your `config/autoload/cors.local.php` and add that to your repository.
 
 ## Testing
 
-Make sure your application sends the **Origin** header and it is set to the correct value, for example *example.com*.
-
-In your **config/autoload/cors.local.php**:
+Make sure your application sends the Origin header and it is set to the correct value, for example `example.com`.
+In your `config/autoload/cors.local.php`:
 
-- when in *permissive mode*, you should see the expected response from the resource
-- when in *restrictive mode*, if the request origin is not listed under `allowed_origins`, you should see a **403 Not authorized** response
+- when in permissive mode, you should see the expected response from the resource
+- when in restrictive mode, if the request origin is not listed under `allowed_origins`, you should see a 403 Not authorized response
 
 ## FAQ
 
@@ -105,13 +102,15 @@ In your **config/autoload/cors.local.php**:
 A: It appears when a browser blocks access to a resource on another origin because the server's response doesn't include an 'Access-Control-Allow-Origin' header, per the browser's CORS (Cross-Origin Resource Sharing) policy.
 
 **Q: What package solves CORS handling in Dotkernel?**
-A: Mezzio CORS, installed by running composer require mezzio/mezzio-cors in the application's root directory.
+A: Mezzio CORS, installed by running `composer require mezzio/mezzio-cors` in the application's root directory.
 
 **Q: What are the setup steps needed to enable CORS?**
-A: Register both Laminas\Diactoros\ConfigProvider::class and Mezzio\Cors\ConfigProvider::class in config/config.php, add $app->pipe(CorsMiddleware::class); to config/pipeline.php (preferably between the error handler and the handler/middleware returning your response), and create a config/autoload/cors.local.php file with your CORS configuration.
+A: Register both `Laminas\Diactoros\ConfigProvider::class` and `Mezzio\Cors\ConfigProvider::class` in `config/config.php`, add `$app->pipe(CorsMiddleware::class);` to `config/pipeline.php` (preferably between the error handler and the handler/middleware returning your response), and create a `config/autoload/cors.local.php` file with your CORS configuration.
 
 **Q: What's the difference between permissive and restrictive mode?**
-A: In permissive mode, allowed_origins is set to ConfigurationInterface::ANY_ORIGIN, making the application accessible from any origin. In restrictive mode, you replace that value with a list of the specific origins that should have access.
+A: In permissive mode, `allowed_origins` is set to `ConfigurationInterface::ANY_ORIGIN`, making the application accessible from any origin.
+In restrictive mode, you replace that value with a list of the specific origins that should have access.
 
 **Q: How do you test whether CORS is configured correctly?**
-A: Make sure your application sends the Origin header set to the correct value. In permissive mode you should see the expected response from the resource; in restrictive mode, if the request origin isn't listed under allowed_origins, you should see a 403 Not authorized response.
+A: Make sure your application sends the Origin header set to the correct value.
+In permissive mode you should see the expected response from the resource; in restrictive mode, if the request origin isn't listed under `allowed_origins`, you should see a 403 Not authorized response.
diff --git a/public/md-articles/how-to/creating-admin-accounts-in-dotkernel-api.md b/public/md-articles/how-to/creating-admin-accounts-in-dotkernel-api.md
index 841bab01..4e185034 100644
--- a/public/md-articles/how-to/creating-admin-accounts-in-dotkernel-api.md
+++ b/public/md-articles/how-to/creating-admin-accounts-in-dotkernel-api.md
@@ -11,96 +11,76 @@ language: "en"
 # Creating admin accounts in Dotkernel API
 
 ## TL;DR
+
 Starting with version 3, Dotkernel API supports dedicated admin accounts.
 They can be created either through a protected API endpoint, which lets you assign one or more admin roles and optional names, or through a terminal command, which is quicker but always assigns the default admin role.
 Both methods leave you with a ready-to-use admin account.
 
-## Creating admin accounts in Dotkernel API
-
-Starting from v3, Dotkernel API introduces support for admin accounts. In this article we will describe two different methods of creating an admin account.
-
-## Method 1: Using API endpoint
+## Method 1: Using API Endpoint
 
 This action can be performed only by an authenticated admin/superuser.
+Once authenticated, call the protected endpoint `POST /admin` with the following JSON body:
 
-Once authenticated call the protected endpoint `POST /admin` with the following **JSON** body:
-
-```
+```json
 {
-   "identity": "{IDENTITY}",
-   "password": "{PASSWORD}",
-   "passwordConfirm": "{PASSWORD}",
-   "firstname": "{FIRSTNAME}",
-   "lastname": "{LASTNAME}",
-   "roles":
- }
+    "identity": "{IDENTITY}",
+    "password": "{PASSWORD}",
+    "passwordConfirm": "{PASSWORD}",
+    "firstname": "{FIRSTNAME}",
+    "lastname": "{LASTNAME}",
+    "roles": ["{ROLE_UUID}"]
+}
 ```
 
 after replacing:
 
 - {IDENTITY} with a valid username OR email address
 - {PASSWORD} with a valid password
-- {ROLE_UUID} with a valid admin role UUID (You can get a list of admin roles by calling the protected endpoint `GET /admin/role`)
+- {ROLE_UUID} with a valid admin role UUID (you can get a list of admin roles by calling the protected endpoint `GET /admin/role`)
 - {FIRSTNAME} and {LASTNAME} are optional
 
-**NOTE:** You can specify multiple admin roles under the *roles* key.
-
+Note: you can specify multiple admin roles under the roles key.
 If the submitted data is valid, the response will be similar to the below:
 
-```
+```json
 {
-     "uuid": "d436b044-be36-11eb-9eb1-78f29ef45f43",
-     "identity": "Letha_Runolfsson96",
-     "firstName": "Oswald",
-     "lastName": "Swift",
-     "status": "active",
-     "roles": [
-     {
-       "uuid": "{ROLE_UUID}"
-     }
-   ][
-         {
-             "uuid": "eaa3d01c-9fc0-11eb-b099-78f29ef45f43",
-             "name": "admin",
-             "created": {
-                 "date": "2021-04-17 23:07:27.000000",
-                 "timezone_type": 3,
-                 "timezone": "Europe/Berlin"
-             },
-             "updated": null
-         }
-     ],
-     "created": {
-         "date": "2021-05-26 17:27:06.194613",
-         "timezone_type": 3,
-         "timezone": "Europe/Berlin"
-     },
-     "updated": {
-         "date": "2021-05-26 17:27:06.279705",
-         "timezone_type": 3,
-         "timezone": "Europe/Berlin"
-     },
-     "_links": {
-         "self": {
-             "href": "http://localhost:8080/admin/d436b044-be36-11eb-9eb1-78f29ef45f43"
-         }
-     }
- }
+    "uuid": "d436b044-be36-11eb-9eb1-78f29ef45f43",
+    "identity": "Letha_Runolfsson96",
+    "firstName": "Oswald",
+    "lastName": "Swift",
+    "status": "active",
+    "roles": ["{ROLE_UUID}"],
+    "created": {
+        "date": "2021-05-26 17:27:06.194613",
+        "timezone_type": 3,
+        "timezone": "Europe/Berlin"
+    },
+    "updated": {
+        "date": "2021-05-26 17:27:06.279705",
+        "timezone_type": 3,
+        "timezone": "Europe/Berlin"
+    },
+    "_links": {
+        "self": {
+            "href": "http://localhost:8080/admin/d436b044-be36-11eb-9eb1-78f29ef45f43"
+        }
+    }
+}
 ```
 
 The new admin account is ready to use.
 
-## Method 2: Using terminal command
+## Method 2: Using Terminal Command
 
 Run the following command in your application's root directory:
 
-```
+```bash
 php ./bin/cli.php admin:create -i {IDENTITY} -p {PASSWORD}
 ```
 
 or
 
-```
+```bash
 php ./bin/cli.php admin:create --identity {IDENTITY} --password {PASSWORD}
 ```
 
@@ -109,10 +89,10 @@ after replacing:
 - {IDENTITY} with a valid username OR email address
 - {PASSWORD} with a valid password
 
-**NOTE:**
+Note:
 
-- if the specified *identity* or *password* contain special characters, make sure you surround them with double quote signs
-- this method does not allow specifying an admin role - newly created accounts will have role of admin
+- if the specified identity or password contain special characters, make sure you surround them with double quote signs
+- this method does not allow specifying an admin role - newly created accounts will have the role of admin
 
 If the submitted data is valid, the outputted response is:
 
@@ -121,26 +101,27 @@ Admin account has been created.
 ```
 
 The new admin account is ready to use.
-
 You can get more help with this command by running:
 
-```
+```bash
 php ./bin/cli.php help admin:create
 ```
 
 ## FAQ
 
 **Q: What are the two ways to create an admin account in Dotkernel API?**
-A: You can either call the protected API endpoint POST /admin with a JSON body, or run the terminal command php ./bin/cli.php admin:create.
+A: You can either call the protected API endpoint `POST /admin` with a JSON body, or run the terminal command `php ./bin/cli.php admin:create`.
 
 **Q: Who can create an admin account via the API endpoint?**
-A: This action can be performed only by an authenticated admin/superuser, calling the protected POST /admin endpoint.
+A: This action can be performed only by an authenticated admin/superuser, calling the protected `POST /admin` endpoint.
 
 **Q: What data does the POST /admin request body need?**
-A: identity, password, passwordConfirm, and roles (one or more valid admin role UUIDs, obtainable via the protected GET /admin/role endpoint). firstname and lastname are optional.
+A: identity, password, passwordConfirm, and roles (one or more valid admin role UUIDs, obtainable via the protected `GET /admin/role` endpoint).
+firstname and lastname are optional.
 
 **Q: What role does an admin get when created via the terminal command?**
 A: The terminal command doesn't allow specifying an admin role, so newly created accounts are given the role of admin.
 
 **Q: How do I get more help with the admin:create command?**
-A: Run php ./bin/cli.php help admin:create. Also note that if the identity or password contain special characters, they must be surrounded with double quote signs.
+A: Run `php ./bin/cli.php help admin:create`.
+Also note that if the identity or password contain special characters, they must be surrounded with double quote signs.
diff --git a/public/md-articles/how-to/database-migrations-and-how-to-use-them.md b/public/md-articles/how-to/database-migrations-and-how-to-use-them.md
index ced97a7e..80e11ab5 100644
--- a/public/md-articles/how-to/database-migrations-and-how-to-use-them.md
+++ b/public/md-articles/how-to/database-migrations-and-how-to-use-them.md
@@ -11,93 +11,80 @@ language: "en"
 # Database migrations and how to use them
 
 ## TL;DR
+
 Database migrations track schema changes so teams can collaborate without ad hoc, convoluted database change messages and can keep column types consistent across the team.
 A package for the Dotkernel stack adds migrations and seeders to the application via a new `php dot` command.
 The article walks through adopting migrations in an existing project, running and naming them, and explains how seeders differ from migrations by adding data rather than changing schema.
 
-## Migrations, the superhero your database deserves
+## Migrations, the Superhero Your Database Deserves
 
 Migrations ease the process of working together on projects, as well as deploying the database changes.
-
- 
-
-A newly released [package](https://github.com/JapSeyz/Dot-migrations) for the Dotkernel stack integrates migrations and seeders into the application; This is all done via the newly introduced "php dot" command that's available in the Dotkernel stack.
-
-This article assumes that you're familiar with the basic concepts of migrations, if you're not, there's an excellent article available [here](https://medium.com/@JapSeyz/database-migrations-and-why-you-should-use-them-11bfde52d7c2)
-
-**To recap the article above, a database migration in a change in the database schema.**
-
- 
+A newly released [package](https://github.com/JapSeyz/Dot-migrations) for the Dotkernel stack integrates migrations and seeders into the application.
+This is all done via the newly introduced "php dot" command that's available in the Dotkernel stack.
+This article assumes that you're familiar with the basic concepts of migrations.
+If you're not, there's an excellent article available [here](https://medium.com/@JapSeyz/database-migrations-and-why-you-should-use-them-11bfde52d7c2).
+To recap the article above, a database migration is a change in the database schema.
 
 ## Benefits
 
-By using migrations and seeders, you ensure a better workflow for teams, as changes to the database no longer require convoluted messages. It also ensures that all team members use the same types with the same limits on each column, and someone doesn't have *VARCHAR(50)* while another has *VARCHAR(150).* **It keeps the database synchronised throughout the team with minimal effort.**
+By using migrations and seeders, you ensure a better workflow for teams, as changes to the database no longer require convoluted messages.
+It also ensures that all team members use the same types with the same limits on each column, and someone doesn't have VARCHAR(50) while another has VARCHAR(150).
+It keeps the database synchronised throughout the team with minimal effort.
+When pushing to production, the deployment script will automatically run the migrations and keep the database schema in sync with the codebase.
+It requires no manual SSH'ing into production servers and no risky manual changes to production databases.
 
-When pushing to production, the deployment script will automatically run the migrations and keep the database schema in sync with the codebase.
+## Getting Started
 
-**It requires no manual SSH'ing into production servers and no risky manual changes to production databases.**
+To setup migrations, simply follow the installation instructions in the package provided for Dotkernel.
+After the package has been successfully setup, you're ready to go.
+To see the available commands, simply write `php dot` in a console that's located in your project root.
 
- 
-
-## Getting started
-
-To setup migrations, simply follow the installation instructions in the package provided for Dotkernel. After the package has been successfully setup, you're ready to go. To see the available commands, simply write "*php dot*" in a console that's located in your project root.
-
- 
-
-## How to use migrations in my project?
+## How to Use Migrations in My Project?
 
 Migrations are very easily adapted to any project.
 
-- *Existing* projects should start by creating a new migration, and mirror the current database design in that file.
-  - *Backup the database*. in case anything unforeseen should happen.
+- Existing projects should start by creating a new migration, and mirror the current database design in that file.
+  - Backup the database, in case anything unforeseen should happen.
   - After the design has been mirrored, the existing tables should be deleted, and the migrations can be run.
 
-1. Whenever you would normally manually touch the database, make a migration for doing it instead. (*php dot make:migration <name>*)
+1. Whenever you would normally manually touch the database, make a migration for doing it instead (`php dot make:migration <name>`).
 2. Give the migrations reasonable names, so it's easy to see their action, and the DB progression, in the project tree.
 3. Run the migrate command, and watch the database automatically generate and run the SQL to update the tables and columns as configured.
 4. Enjoy a safe and worry free database that won't suffer from manually touching it.
 
- 
-
-Notice; Migrations are stored in version control, so whenever you pull an update, quickly run *php dot migrate*, as it will only ever migrate new files, and leave out the ones that have been run already.
-
- 
+Notice: migrations are stored in version control, so whenever you pull an update, quickly run `php dot migrate`, as it will only ever migrate new files, and leave out the ones that have been run already.
 
 ## Seeders
 
-If you need to add some data to a table, e.g. adding a default admin profile on a fresh installation, this can be done via Seeders.
-
-*Migrations manage the database layouts, seeders add data to the database.*
-
-Seeders can be configured to run every time a certain migration is run, so no matter when you or how you reset your database, it'll make sure that there's always a default admin profile when the *CreateAdminTableMigration* is run.
-
-Seeders are created the same way as migrations, and also benefits hugely from being given reasonable names that explain what they do.
+If you need to add some data to a table, e.g. adding a default admin profile on a fresh installation, this can be done via seeders.
+Migrations manage the database layouts, seeders add data to the database.
+Seeders can be configured to run every time a certain migration is run, so no matter when you or how you reset your database, it'll make sure that there's always a default admin profile when the CreateAdminTableMigration is run.
+Seeders are created the same way as migrations, and also benefit hugely from being given reasonable names that explain what they do.
 
 1. Create the required seeders, one for each table is the best practice, so you can have a "UserTableSeeder" and a "CarTableSeeder" etc.
-2. Setup when these seeders should run;
-  - When running a migration
-  - Via a console-command, this is used to seed x amount of rows of (random) data to the database for testing.
-
----
-
-## Acknowledgements
-
-The images in the article shows screenshots from [MySQL Workbench](https://www.mysql.com/products/workbench/), and the migration package used is [Phinx](https://phinx.org/)
+2. Setup when these seeders should run:
+   - When running a migration
+   - Via a console command, this is used to seed x amount of rows of (random) data to the database for testing.
 
 ## FAQ
 
 **Q: What is a database migration?**
-A: A database migration is a change to the database schema. The Dotkernel stack integrates migrations (and seeders) via a package that adds the "php dot" command to the application.
+A: A database migration is a change to the database schema.
+The Dotkernel stack integrates migrations (and seeders) via a package that adds the "php dot" command to the application.
 
 **Q: What are the benefits of using migrations and seeders?**
-A: They keep the database synchronised across the team with minimal effort, so column types and limits stay consistent instead of drifting (e.g. one dev using VARCHAR(50) and another VARCHAR(150)). Deployment scripts can also run migrations automatically in production, avoiding manual SSH access and risky manual database changes.
+A: They keep the database synchronised across the team with minimal effort, so column types and limits stay consistent instead of drifting (e.g. one dev using VARCHAR(50) and another VARCHAR(150)).
+Deployment scripts can also run migrations automatically in production, avoiding manual SSH access and risky manual database changes.
 
 **Q: How do I create a new migration?**
-A: Run php dot make:migration <name>, giving the migration a reasonable name so its action and the database's progression are easy to follow in the project tree.
+A: Run `php dot make:migration <name>`, giving the migration a reasonable name so its action and the database's progression are easy to follow in the project tree.
 
 **Q: What's the difference between migrations and seeders?**
 A: Migrations manage the database layout/schema, while seeders add data to the database, such as adding a default admin profile on a fresh installation.
 
 **Q: What happens when I run php dot migrate more than once?**
-A: Since migrations are stored in version control, running php dot migrate will only ever run new migration files, leaving out the ones that have already been run.
+A: Since migrations are stored in version control, running `php dot migrate` will only ever run new migration files, leaving out the ones that have already been run.
+
+## Acknowledgements
+
+The images in the article show screenshots from [MySQL Workbench](https://www.mysql.com/products/workbench/), and the migration package used is [Phinx](https://phinx.org/).
diff --git a/public/md-articles/how-to/doctrine-cache-in-mezzio-and-dotkernel.md b/public/md-articles/how-to/doctrine-cache-in-mezzio-and-dotkernel.md
index ee4a5dc7..b02a0c90 100644
--- a/public/md-articles/how-to/doctrine-cache-in-mezzio-and-dotkernel.md
+++ b/public/md-articles/how-to/doctrine-cache-in-mezzio-and-dotkernel.md
@@ -11,47 +11,47 @@ language: "en"
 # Doctrine Cache in Mezzio and Dotkernel
 
 ## TL;DR
+
 Running Doctrine ORM in production without any caching strategy wastes CPU cycles regenerating metadata and queries on every request.
 This article configures Doctrine's `metadata_cache`, `query_cache`, and `result_cache` through psr/container, using `PhpFileCache` and a default result cache lifetime of 3600 seconds.
 It walks through enabling these caches both directly on a query and on a Doctrine Paginator-based collection, with real examples from Dotkernel Admin.
 Note: a 2024 follow-up article covers the same topic using Symfony Cache instead.
 
-## Doctrine caching in Dotkernel
-
-> Following version 2 of doctrine/cache, in 2024 we published an update to this article here:[https://www.dotkernel.com/dotkernel/doctrine-cache-using-symfony-cache/](https://www.dotkernel.com/dotkernel/doctrine-cache-using-symfony-cache/)
+## Doctrine Caching in Dotkernel
 
-Using an **ORM** in **production** without any sort of cache strategy is a very bad move. The Database server chokes; lots of CPU cycles wasted only to generate metadata and queries over and over again at each request; the system slows down and so on.
-
-Following [Doctrine documentation](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/caching.html#integrating-with-the-orm) [ 'orm_default' => [ // it is recommended to disable doctrine cache on development // just comment any type of cache you dont want to be applied on development 'query_cache' => \Doctrine\Common\Cache\PhpFileCache::class, 'metadata_cache' => \Doctrine\Common\Cache\PhpFileCache::class, 'result_cache' => \Doctrine\Common\Cache\PhpFileCache::class ] ], we choose to configure doctrine cache system through **psr/container**.
+> Following version 2 of doctrine/cache, in 2024 we published an update to this article here: [https://www.dotkernel.com/dotkernel/doctrine-cache-using-symfony-cache/](https://www.dotkernel.com/dotkernel/doctrine-cache-using-symfony-cache/)
 
+Using an ORM in production without any sort of cache strategy is a very bad move.
+The database server chokes; lots of CPU cycles wasted only to generate metadata and queries over and over again at each request; the system slows down and so on.
+Following [Doctrine documentation](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/caching.html#integrating-with-the-orm), we choose to configure the Doctrine cache system through psr/container.
 The main parts we are going to use are `query_cache`, `metadata_cache` and `result_cache`.
-
 As cache type we choose `PhpFileCache` and for result cache we are setting a lifetime of 3600 seconds.
 
 ## Configuration
 
-In the file: **config/autoload/doctrine.global.php** add the below entry:
+In the file `config/autoload/doctrine.global.php` add the below entry:
 
-```
+```php
 'doctrine' =>
         ]
     ],
 'resultCacheLifetime' => 3600
 ```
 
-In the file: **config/autoload/local.php** add the below entry in the `doctrine` section:
+In the file `config/autoload/local.php` add the below entry in the `doctrine` section:
 
-```
+```php
     'configuration' =>
     ],
 ```
 
 ## Metadata Cache
 
-Your class metadata is being parsed on each request. Instead of **parsing** this information we should **cache** it using one of the cache drivers.
+Your class metadata is being parsed on each request.
+Instead of parsing this information we should cache it using one of the cache drivers.
 We enabled this by adding the following `metadata_cache` key to our doctrine configuration:
 
-```
+```php
 'doctrine' =>
         ]
     ]
@@ -59,11 +59,11 @@ We enabled this by adding the following `metadata_cache` key to our doctrine con
 
 ## Query Cache
 
-It is highly recommended that in a production environment you cache the transformation of a **DQL** query to its **SQL** counterpart.
-It doesn't make sense to do this parsing multiple times as it doesn't change unless you alter the **DQL** query.
+It is highly recommended that in a production environment you cache the transformation of a DQL query to its SQL counterpart.
+It doesn't make sense to do this parsing multiple times as it doesn't change unless you alter the DQL query.
 We enabled this by adding the following `query_cache` key to our doctrine configuration:
 
-```
+```php
 'doctrine' =>
         ]
     ]
@@ -71,17 +71,17 @@ We enabled this by adding the following `query_cache` key to our doctrine config
 
 ### Usage
 
-```
+```php
 $query = $em->createQuery('select u from \Entities\User u');
 $query->useQueryCache(true);
 ```
 
 ## Result Cache
 
-The result cache can be used to cache the results of your queries so that doctrine don't have to query the database or hydrate the data again after the first time.
+The result cache can be used to cache the results of your queries so that doctrine doesn't have to query the database or hydrate the data again after the first time.
 We enabled this by adding the following `result_cache` key to our doctrine configuration:
 
-```
+```php
 'doctrine' =>
         ]
     ]
@@ -89,30 +89,29 @@ We enabled this by adding the following `result_cache` key to our doctrine confi
 
 ### Usage
 
-```
+```php
 $query = $em->createQuery('select u from \Entities\User u');
 $query->enableResultCache();
 ```
 
-Note: You can set a `lifetime` for result cache to live before it will be rewrite by simply passing the value as the first argument:
+Note: you can set a `lifetime` for how long the result cache should live before it will be rewritten by simply passing the value as the first argument:
 
-```
-$query->enableResultCache( $resultCacheLifetime);
+```php
+$query->enableResultCache($resultCacheLifetime);
 ```
 
-Note: You can set a custom `ID` for the result cache which is automatically generated for you if you don't set a custom ID yourself:
+Note: you can set a custom `ID` for the result cache, which is automatically generated for you if you don't set a custom ID yourself:
 
-```
-$query->enableResultCache( $resultCacheLifetime, 'my_custom_id');
+```php
+$query->enableResultCache($resultCacheLifetime, 'my_custom_id');
 ```
 
 ## Dotkernel Admin Example
 
-Below there is the code used in [Dotkernel Admin](https://github.com/dotkernel/admin) in order to [list all Admins](https://github.com/dotkernel/admin/blob/3.0/src/User/src/Repository/AdminRepository.php#L78).
+Below is the code used in [Dotkernel Admin](https://github.com/dotkernel/admin) in order to [list all Admins](https://github.com/dotkernel/admin/blob/3.0/src/User/src/Repository/AdminRepository.php#L78).
+It uses both `query_cache` and `result_cache`.
 
-Is using both `query_cache`  and `result_cache`.
-
-```
+```php
 $qb = $this->getEntityManager()->createQueryBuilder();
 $qb->select('admin')
 ->from(Admin::class, 'admin');
@@ -129,11 +128,11 @@ $qb->orderBy('admin.' . $sort, $order);
 return $qb->getQuery()->useQueryCache(true)->enableResultCache($this->getCacheLifetime())->getResult();
 ```
 
-## How to return Collections
+## How to Return Collections
 
-For returning collections that extends **Doctrine Paginator** (`Doctrine\ORM\Tools\Pagination\Paginator`) just enable result and/or query cache **before** passing query builder to collection
+For returning collections that extend Doctrine Paginator (`Doctrine\ORM\Tools\Pagination\Paginator`), just enable result and/or query cache before passing the query builder to the collection:
 
-```
+```php
 $qb = $this->getEntityManager()->createQueryBuilder();
 $qb->select('collection')
 ->from(MyCollection::class, 'collection');
@@ -146,9 +145,9 @@ $qb->getQuery()->enableResultCache($this->getCacheLifetime())->useQueryCache(tru
 return new MyCollection($qb);
 ```
 
-and the **MyCollection** look like:
+and the MyCollection class looks like:
 
-```
+```php
 <?php
 
 use Doctrine\ORM\Tools\Pagination\Paginator;
@@ -162,11 +161,6 @@ class MyCollection extends Paginator
 }
 ```
 
-## References
-
-- [Doctrine Advanced Configuration](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/advanced-configuration.html)
-- [Doctrine Caching Documentation](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/caching.html)
-
 ## FAQ
 
 **Q: Is this article still current?**
@@ -176,10 +170,16 @@ A: The article notes that following version 2 of doctrine/cache, an updated vers
 A: query_cache, metadata_cache and result_cache, configured through psr/container using PhpFileCache as the cache type.
 
 **Q: What is the default result cache lifetime?**
-A: A lifetime of 3600 seconds, set via resultCacheLifetime in config/autoload/doctrine.global.php.
+A: A lifetime of 3600 seconds, set via `resultCacheLifetime` in `config/autoload/doctrine.global.php`.
 
 **Q: How do I enable query cache and result cache in code?**
-A: Call $query->useQueryCache(true) and $query->enableResultCache() on the query object. enableResultCache() can also take a lifetime as its first argument and a custom cache ID as an argument, otherwise one is auto-generated.
+A: Call `$query->useQueryCache(true)` and `$query->enableResultCache()` on the query object.
+`enableResultCache()` can also take a lifetime as its first argument and a custom cache ID as a second argument, otherwise one is auto-generated.
 
 **Q: How should caching be enabled for a Doctrine Paginator-based collection?**
-A: Enable result and/or query cache on the query builder's query before passing the query builder into the collection (a class extending Doctrine\ORM\Tools\Pagination\Paginator).
+A: Enable result and/or query cache on the query builder's query before passing the query builder into the collection (a class extending `Doctrine\ORM\Tools\Pagination\Paginator`).
+
+## Resources
+
+- [Doctrine Advanced Configuration](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/advanced-configuration.html)
+- [Doctrine Caching Documentation](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/caching.html)
diff --git a/public/md-articles/how-to/generating-a-doctrine-migration-without-dropping-custom-tables.md b/public/md-articles/how-to/generating-a-doctrine-migration-without-dropping-custom-tables.md
index 1e9f44be..7ca3bcac 100644
--- a/public/md-articles/how-to/generating-a-doctrine-migration-without-dropping-custom-tables.md
+++ b/public/md-articles/how-to/generating-a-doctrine-migration-without-dropping-custom-tables.md
@@ -11,68 +11,72 @@ language: "en"
 # Generating a doctrine migration without dropping custom tables
 
 ## TL;DR
+
 When an application has custom, unmapped database tables, running `doctrine-migrations diff` will try to drop them, since no Doctrine entity describes them.
 This article shows how to prevent that using the `--filter-expression` option, including how to filter multiple table prefixes at once.
 It also flags a Windows PowerShell quirk where the caret in the regex gets stripped, and how to work around it.
 
-## Generating a doctrine migration without dropping custom tables
-
-If your application needs to hold some **custom** (*unmapped*) tables in the database, then generating migrations with doctrine-migrations diff will try to **drop** the custom tables. This article provides a solution on how to avoid dropping those tables.
-
 ## Usage
 
-Run the following command in your application’s root directory:
+If your application needs to hold some custom (unmapped) tables in the database, then generating migrations with `doctrine-migrations diff` will try to drop the custom tables.
+This article provides a solution on how to avoid dropping those tables.
+Run the following command in your application's root directory:
 
-```
+```bash
 vendor/bin/doctrine-migrations diff
 ```
 
-If you have mapping modifications, this will create a new migration file under **data/doctrine/migrations/** directory. Opening the migration file, you will notice that it contains some queries that will drop your `oauth_*` tables because they are unmapped (there is no doctrine entity describing them). You should delete your latest migration with the **DROP** queries in it as we will create another one, without the **DROP** queries in it. In order to avoid dropping these tables, you need to add a parameter called filter-expression.
-
+If you have mapping modifications, this will create a new migration file under the `data/doctrine/migrations/` directory.
+Opening the migration file, you will notice that it contains some queries that will drop your `oauth_*` tables because they are unmapped (there is no doctrine entity describing them).
+You should delete your latest migration with the DROP queries in it, as we will create another one, without the DROP queries in it.
+In order to avoid dropping these tables, you need to add a parameter called filter-expression.
 The command to be executed without dropping these tables looks like this:
 
-On **Windows** (use double quotes):
+On Windows (use double quotes):
 
-```
+```bash
 vendor/bin/doctrine-migrations diff --filter-expression="/^(?!oauth_)/"
 ```
 
-On **Linux/macOS** (use single quotes):
+On Linux/macOS (use single quotes):
 
-```
+```bash
 vendor/bin/doctrine-migrations diff --filter-expression='/^(?!oauth_)/'
 ```
 
-## Filtering multiple unmapped table patterns
+## Filtering Multiple Unmapped Table Patterns
 
-If your database contains multiple unmapped table groups, then the pattern in `filter-expression` should hold all table prefixes concatenated by pipe character (`|`). For example, if you need to filter tables prefixed with `foo_` and `bar_`, then the command should look like this:
+If your database contains multiple unmapped table groups, then the pattern in `filter-expression` should hold all table prefixes concatenated by the pipe character (`|`).
+For example, if you need to filter tables prefixed with `foo_` and `bar_`, then the command should look like this:
 
 On Windows:
 
-```
+```bash
 vendor/bin/doctrine-migrations diff --filter-expression="/^(?!foo_|bar_)/"
 ```
 
 On Linux/macOS:
 
-```
+```bash
 vendor/bin/doctrine-migrations diff --filter-expression='/^(?!foo_|bar_)/'
 ```
 
 ## Troubleshooting
 
-On **Windows**, running the command in *PowerShell* might still add the `DROP TABLE oauth_*` queries to the migration file. This happens because for *PowerShell* the caret (`^`) is a special character, so it gets dropped (`"/^(?!oauth_)/"` becomes `"/(?!oauth_)/"` when it reaches your command). Escaping it will not help either.
+On Windows, running the command in PowerShell might still add the `DROP TABLE oauth_*` queries to the migration file.
+This happens because for PowerShell the caret (`^`) is a special character, so it gets dropped (`"/^(?!oauth_)/"` becomes `"/(?!oauth_)/"` when it reaches your command).
+Escaping it will not help either.
 In this case, we recommend running the command:
 
 - directly from your IDE
-- using `Linux shell`
-- from the `Command Prompt`
+- using Linux shell
+- from the Command Prompt
 
 ## Help
 
 You can get more help with this command by running:
 
-```
+```bash
 vendor/bin/doctrine-migrations help diff
 ```
 
@@ -82,10 +86,11 @@ vendor/bin/doctrine-migrations help diff
 A: Because those tables are unmapped (there's no Doctrine entity describing them), so diff generates queries that drop them when it creates a new migration file.
 
 **Q: How do I avoid dropping unmapped tables when generating a migration?**
-A: Delete the migration containing the DROP queries, then re-run the diff command with a filter-expression parameter, e.g. vendor/bin/doctrine-migrations diff --filter-expression='/^(?!oauth_)/' on Linux/macOS (single quotes) or with double quotes on Windows.
+A: Delete the migration containing the DROP queries, then re-run the diff command with a filter-expression parameter, e.g. `vendor/bin/doctrine-migrations diff --filter-expression='/^(?!oauth_)/'` on Linux/macOS (single quotes) or with double quotes on Windows.
 
 **Q: How do I filter multiple unmapped table prefixes at once?**
-A: Concatenate the table prefixes in the filter-expression pattern with a pipe character, for example --filter-expression='/^(?!foo_|bar_)/' to exclude tables prefixed with foo_ and bar_.
+A: Concatenate the table prefixes in the filter-expression pattern with a pipe character, for example `--filter-expression='/^(?!foo_|bar_)/'` to exclude tables prefixed with foo_ and bar_.
 
 **Q: Why might Windows PowerShell still drop the tables even with a filter expression?**
-A: PowerShell treats the caret (^) as a special character and strips it, turning "/^(?!oauth_)/" into "/(?!oauth_)/" by the time it reaches the command, and escaping it doesn't help. The recommended workaround is to run the command from your IDE, a Linux shell, or the Command Prompt instead.
+A: PowerShell treats the caret (^) as a special character and strips it, turning "/^(?!oauth_)/" into "/(?!oauth_)/" by the time it reaches the command, and escaping it doesn't help.
+The recommended workaround is to run the command from your IDE, a Linux shell, or the Command Prompt instead.
diff --git a/public/md-articles/how-to/implementation-of-seo-friendly-url-in-an-generic-laminas-mezzio-app.md b/public/md-articles/how-to/implementation-of-seo-friendly-url-in-an-generic-laminas-mezzio-app.md
index 26577a55..82df9554 100644
--- a/public/md-articles/how-to/implementation-of-seo-friendly-url-in-an-generic-laminas-mezzio-app.md
+++ b/public/md-articles/how-to/implementation-of-seo-friendly-url-in-an-generic-laminas-mezzio-app.md
@@ -11,44 +11,42 @@ language: "en"
 # Implementation of SEO friendly URL in an generic Laminas Mezzio app
 
 ## TL;DR
+
 Human-readable URL slugs improve readability, SEO, and shareability compared to raw numeric IDs in URLs.
 This article shows how to add slug support to a Mezzio application using the gedmo/doctrine-extensions package.
 It covers installing the package via Composer, registering its SluggableListener with Doctrine, and adding a slug column generated from an existing field (such as identity) via the `@Gedmo\Slug` annotation.
 
-**Prerequisites:**
+Prerequisites:
 
 - [Mezzio App](https://docs.mezzio.dev/)
 - [Doctrine](https://www.doctrine-project.org/)
 
-In the vast digital landscape of the internet, where websites compete for attention, having a well-crafted URL can make a significant difference. By incorporating human-readable slugs into website URLs, we can enhance user experience, improve search engine optimization (SEO), and foster better engagement. In this article, we discuss the importance, benefits and how to implement human-readable URLs.
-
+In the vast digital landscape of the internet, where websites compete for attention, having a well-crafted URL can make a significant difference.
+By incorporating human-readable slugs into website URLs, we can enhance user experience, improve search engine optimization (SEO), and foster better engagement.
+In this article, we discuss the importance, benefits and how to implement human-readable URLs.
 The first 3 reasons why we should consider implementing slugs:
 
 - Readability and User-Friendly Experience
 - Search Engine Optimization (SEO)
 - Shareability and Trustworthiness
 
-## How to implement slugs into Dotkernel, a practical example:
-
-Let's consider we want to implement a feature that gives users the possibility to view other user's profile.
-
-When viewing another user's profile we have this URL: **website.com/user/11** and this doesn't look so appealing, am I right?
-
-So, the solution is to format the URL in a human-readable way, like this : ****website.com/user/**john-doe**.
+## How to Implement Slugs into Dotkernel, a Practical Example
 
+Let's consider we want to implement a feature that gives users the possibility to view other users' profiles.
+When viewing another user's profile we have this URL: website.com/user/11, and this doesn't look so appealing, am I right?
+So, the solution is to format the URL in a human-readable way, like this: website.com/user/john-doe.
 To implement slugs into our codebase we are going to use a popular package, [gedmo/doctrine-extensions](https://packagist.org/packages/gedmo/doctrine-extensions).
+First, we need to install the package via composer by running:
 
-First, we need to install the package via composer by running :
-
-```
+```bash
 composer require gedmo/doctrine-extensions
 ```
 
 After installing, we need to register the package's event listener into doctrine.
+To do this, add the following code block in your doctrine global configuration.
+In our case it would be in the `doctrine.global.php` file.
 
-To do this, add the following codeblock in your doctrine global configuration. In our case it would be in the **doctrine.global.php** file.
-
-```
+```php
 'doctrine' => [
     'event_manager' => [
         'orm_default' => [
@@ -60,9 +58,10 @@ To do this, add the following codeblock in your doctrine global configuration. I
 ]
 ```
 
-This is all the configuration you will need, the next step is to create a new database column that will be our slug, we will add the column in the **src/User/src/Entity/User.php** entity and run the migrations.
+This is all the configuration you will need, the next step is to create a new database column that will be our slug.
+We will add the column in the `src/User/src/Entity/User.php` entity and run the migrations.
 
-```
+```php
 use Gedmo\Mapping\Annotation as Gedmo;
 
 ...
@@ -79,11 +78,9 @@ protected string $identity;
 protected string $slug;
 ```
 
-When generating the slug we can specify what field(s) to be used, in our case the slug will be generated using the 'identity' field, more details here.
-
+When generating the slug we can specify what field(s) to be used; in our case the slug will be generated using the 'identity' field.
 Now you can create a new user and see that the slug column was autocompleted.
-
-To wrap things up, human-readable URL's are a must nowadays, thanks to its swift implementation and multiple benefits.
+To wrap things up, human-readable URLs are a must nowadays, thanks to their swift implementation and multiple benefits.
 
 ## FAQ
 
@@ -91,10 +88,10 @@ To wrap things up, human-readable URL's are a must nowadays, thanks to its swift
 A: Readability and a more user-friendly experience, better search engine optimization (SEO), and improved shareability and trustworthiness of the URL.
 
 **Q: What package is used to generate slugs in this example?**
-A: gedmo/doctrine-extensions, installed by running composer require gedmo/doctrine-extensions.
+A: gedmo/doctrine-extensions, installed by running `composer require gedmo/doctrine-extensions`.
 
 **Q: How is the slug listener registered with Doctrine?**
-A: By adding Gedmo\Sluggable\SluggableListener::class under the doctrine.event_manager.orm_default.subscribers configuration, e.g. in doctrine.global.php.
+A: By adding `Gedmo\Sluggable\SluggableListener::class` under the `doctrine.event_manager.orm_default.subscribers` configuration, e.g. in `doctrine.global.php`.
 
 **Q: How is the slug field configured on the entity in this example?**
-A: A new slug column is added (e.g. to src/User/src/Entity/User.php) annotated with @Gedmo\Slug(fields={"identity"}), so the slug is generated automatically from the identity field, for example when a new user is created.
+A: A new slug column is added (e.g. to `src/User/src/Entity/User.php`) annotated with `@Gedmo\Slug(fields={"identity"})`, so the slug is generated automatically from the identity field, for example when a new user is created.
diff --git a/public/md-articles/how-to/installing-almalinux-10-in-wsl2-php-mariadb-composer-phpmyadmin.md b/public/md-articles/how-to/installing-almalinux-10-in-wsl2-php-mariadb-composer-phpmyadmin.md
index 72e2ab44..3d583c06 100644
--- a/public/md-articles/how-to/installing-almalinux-10-in-wsl2-php-mariadb-composer-phpmyadmin.md
+++ b/public/md-articles/how-to/installing-almalinux-10-in-wsl2-php-mariadb-composer-phpmyadmin.md
@@ -11,15 +11,14 @@ language: "en"
 # Installing AlmaLinux 10 in WSL2: PHP, MariaDB, Composer, PhpMyadmin
 
 ## TL;DR
+
 With the release of AlmaLinux OS 10, Dotkernel created a new WSL2 development environment recipe offering performance, security, and hardware improvements over AlmaLinux 9.
 The recipe sets up WSL2, AlmaLinux 10, PHP, Apache, MariaDB, Git, Composer, Node.js, and PhpMyAdmin.
 It also covers the OS/hardware requirements, installing the distro, and running PHP projects directly or via virtual hosts.
 
-With the recent release of [AlmaLinux OS 10](https://almalinux.org/blog/2025-05-27-welcoming-almalinux-10/), we have created a new recipe for our WSL development environment. Compared to its predecessor, AlmaLinux 10 provides performance enhancements, security updates and improved hardware support.
-
 ## What You Get
 
-Like for [AlmaLinux 9](https://www.dotkernel.com/php-development/almalinux-9-in-wsl2-install-php-apache-mariadb-composer-phpmyadmin/), the WSL recipe sets up the development environment with all the components a regular PHP developer needs:
+Like for AlmaLinux 9, the WSL recipe sets up the development environment with all the components a regular PHP developer needs:
 
 - WSL2 - Windows Subsystem for Linux.
 - AlmaLinux 10 - Free and open source Linux distribution.
@@ -29,12 +28,11 @@ Like for [AlmaLinux 9](https://www.dotkernel.com/php-development/almalinux-9-in-
 - Git - Distributed version control system.
 - Composer - Application-level dependency manager.
 - Node.js - JavaScript runtime environment.
-- PhpMyAdmin - Open source administration tool for PostgreSQL and MariaDB.
+- PhpMyAdmin - Open source administration tool for MySQL and MariaDB.
 
 ## Requirements
 
 Make sure that you have the [minimum requirements for running WSL2](https://learn.microsoft.com/en-us/windows/wsl/install#prerequisites).
-
 OS-wise you must be running:
 
 - Windows 10:
@@ -42,54 +40,52 @@ OS-wise you must be running:
   - For ARM64 systems: Version 2004 or later with Build 19041 or later.
 - or Windows 11.
 
-Hardware-wise, you need virtualization support. On some older hardware that supports this feature, it may be disabled from the BIOS.
+Hardware-wise, you need virtualization support.
+On some older hardware that supports this feature, it may be disabled from the BIOS.
 
-WSL2 needs Virtual Machine Platform feature enabled. You can enable it via the PowerShell running as an Administrator:
+WSL2 needs the Virtual Machine Platform feature enabled.
+You can enable it via PowerShell running as an Administrator:
 
-```
+```bash
 dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
 ```
 
-## Installing the distro
+## Installing the Distro
 
 Start by downloading and installing the Linux distro with this command:
 
-```
+```bash
 wsl --install -d AlmaLinux-10
 ```
 
 If everything ran ok, you are asked to enter a password at the end.
-
-Next run each of the [ansible playbook commands](https://docs.dotkernel.org/development/v2/setup/setup-packages/) to install the development components.
+Next, run each of the [ansible playbook commands](https://docs.dotkernel.org/development/v2/setup/setup-packages/) to install the development components.
 
 ## Using WSL2 with AlmaLinux 10
 
-You can start AlmaLinux10 by executing this coomand in the Windows Terminal:
+You can start AlmaLinux 10 by executing this command in the Windows Terminal:
 
-```
+```bash
 wsl -d AlmaLinux-10
 ```
 
 Our PHP projects can be run by navigating into the root project folder and running this command:
 
-```
+```bash
 php -S 0.0.0.0:8080 -t public
 ```
 
 Then you need to navigate to `http://localhost:8080` in your preferred browser.
 
-### Running the Application Via Virtual Hosts
+### Running the Application via Virtual Hosts
 
-An **easier way** to run your applications is via virtual hosts. The full instructions to set up your virtual hosts are in the [Create virtualhosts page](https://docs.dotkernel.org/development/v2/virtualhosts/create-virtualhost/).
+An easier way to run your applications is via virtual hosts.
+The full instructions to set up your virtual hosts are in the [Create virtualhosts page](https://docs.dotkernel.org/development/v2/virtualhosts/create-virtualhost/).
 
 After you set up your virtual hosts and install your project in e.g. the `/var/www/example.localhost/html` folder, you can run the application in the browser by accessing `example.localhost`.
 
-If you run into any issues, make sure to first check our [FAQ page](https://docs.dotkernel.org/development/v2/faq/). If all else fails, [create an issue](https://github.com/dotkernel/development/issues) with details and we can talk.
-
-## Additional Resources
-
-- [Full AlmaLinux 10 Installation Instructions](https://docs.dotkernel.org/development/v2/setup/installation/)
-- [AlmaLinux 9 in WSL2 with PHP, Mariadb, Composer, PhpMyadmin instructions](https://www.dotkernel.com/php-development/almalinux-9-in-wsl2-install-php-apache-mariadb-composer-phpmyadmin/)
+If you run into any issues, make sure to first check the [FAQ page](https://docs.dotkernel.org/development/v2/faq/).
+If all else fails, [create an issue](https://github.com/dotkernel/development/issues) with details so the team can help.
 
 ## FAQ
 
@@ -97,13 +93,20 @@ If you run into any issues, make sure to first check our [FAQ page](https://docs
 A: It sets up a full PHP development environment: WSL2, AlmaLinux 10, PHP, Apache, MariaDB, Git, Composer, Node.js and PhpMyAdmin.
 
 **Q: What are the OS and hardware requirements?**
-A: Windows 10 (Version 1903+ / Build 18362.1049+ for x64, or Version 2004+ / Build 19041+ for ARM64) or Windows 11, plus hardware virtualization support. If needed, enable the Virtual Machine Platform feature via dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart in an administrator PowerShell.
+A: Windows 10 (Version 1903+ / Build 18362.1049+ for x64, or Version 2004+ / Build 19041+ for ARM64) or Windows 11, plus hardware virtualization support.
+If needed, enable the Virtual Machine Platform feature via `dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart` in an administrator PowerShell.
 
 **Q: How do I install AlmaLinux 10 via WSL2?**
-A: Run wsl --install -d AlmaLinux-10, set a password when prompted, then run each of the Ansible playbook commands from the Dotkernel docs to install the development components.
+A: Run `wsl --install -d AlmaLinux-10`, set a password when prompted, then run each of the Ansible playbook commands from the Dotkernel docs to install the development components.
 
 **Q: How do I run a PHP project after setup?**
-A: Either run php -S 0.0.0.0:8080 -t public from the project root and browse to http://localhost:8080, or, more easily, set up virtual hosts per the Dotkernel docs and access the project at its configured hostname (e.g. example.localhost).
+A: Either run `php -S 0.0.0.0:8080 -t public` from the project root and browse to http://localhost:8080, or, more easily, set up virtual hosts per the Dotkernel docs and access the project at its configured hostname (e.g. example.localhost).
 
 **Q: What should I do if I run into issues during setup?**
-A: First check the Dotkernel FAQ page. If that doesn't resolve it, create an issue on the dotkernel/development GitHub repository with details.
+A: First check the Dotkernel FAQ page.
+If that doesn't resolve it, create an issue on the dotkernel/development GitHub repository with details.
+
+## Resources
+
+- [Full AlmaLinux 10 Installation Instructions](https://docs.dotkernel.org/development/v2/setup/installation/)
+- [AlmaLinux 9 in WSL2 with PHP, Mariadb, Composer, PhpMyadmin instructions](https://www.dotkernel.com/php-development/almalinux-9-in-wsl2-install-php-apache-mariadb-composer-phpmyadmin/)
diff --git a/public/md-articles/how-to/list-available-endpoints-in-dotkernel-api-using-dot-cli.md b/public/md-articles/how-to/list-available-endpoints-in-dotkernel-api-using-dot-cli.md
index 2d41cf52..e2c5a98e 100644
--- a/public/md-articles/how-to/list-available-endpoints-in-dotkernel-api-using-dot-cli.md
+++ b/public/md-articles/how-to/list-available-endpoints-in-dotkernel-api-using-dot-cli.md
@@ -11,22 +11,24 @@ language: "en"
 # List available endpoints in Dotkernel API using dot-cli
 
 ## TL;DR
+
 Starting from version 3, Dotkernel API uses the dot-cli package to list all of its available endpoints via the `route:list` command.
 The command's output can be filtered by route name, path, or HTTP method, and filters are case-insensitive and combinable.
 
-## Displaying Dotkernel API endpoints using dot-cli
+## Displaying Dotkernel API Endpoints Using dot-cli
 
 Starting from version 3, Dotkernel API uses [dot-cli](https://github.com/dotkernel/dot-cli) to display a list of available endpoints.
 
 ## Usage
 
-Run the following command in your application’s root directory:
+Run the following command in your application's root directory:
 
-```
+```bash
 php ./bin/cli.php route:list
 ```
 
-The command runs through all routes and extracts endpoint information in realtime. The output should be similar to the following:
+The command runs through all routes and extracts endpoint information in realtime.
+The output should be similar to the following:
 
 ```
 +--------+---------------------------------+--------------------------------+
@@ -72,21 +74,22 @@ The command runs through all routes and extracts endpoint information in realtim
 +--------+---------------------------------+--------------------------------+
 ```
 
-## Filtering results
+## Filtering Results
 
 The following filters can be applied when displaying the routes list:
 
-- Filter routes by name, using: `-i|--name[=NAME]`
-- Filter routes by path, using: `-p|--path[=PATH]`
-- Filter routes by method, using: `-m|--method[=METHOD]`
+- Filter routes by name, using: `-i|--name`
+- Filter routes by path, using: `-p|--path`
+- Filter routes by method, using: `-m|--method`
 
 The filters are case-insensitive and can be combined.
 
 ### Example
 
-Let's find which path should one call to register their user account. For this we will list routes where method is **POST** and name contains the string **register**:
+Let's find which path should one call to register their user account.
+For this we will list routes where method is POST and name contains the string register:
 
-```
+```bash
 php ./bin/cli.php route:list --method=post --name=register
 ```
 
@@ -102,7 +105,7 @@ The output is the following:
 
 You can get more help with this command by running:
 
-```
+```bash
 php ./bin/cli.php route:list --help
 ```
 
@@ -112,13 +115,15 @@ php ./bin/cli.php route:list --help
 A: Starting from version 3, Dotkernel API uses dot-cli to display a list of available endpoints.
 
 **Q: Which command lists all routes?**
-A: Run php ./bin/cli.php route:list in your application's root directory. It runs through all routes and extracts endpoint information in realtime, outputting a table with Method, Name and Path columns.
+A: Run `php ./bin/cli.php route:list` in your application's root directory.
+It runs through all routes and extracts endpoint information in realtime, outputting a table with Method, Name and Path columns.
 
 **Q: How can the route list be filtered?**
-A: You can filter routes by name using -i|--name, by path using -p|--path, or by method using -m|--method. The filters are case-insensitive and can be combined.
+A: You can filter routes by name using `-i|--name`, by path using `-p|--path`, or by method using `-m|--method`.
+The filters are case-insensitive and can be combined.
 
 **Q: How would you find the endpoint used to register a user account?**
-A: By combining the method and name filters: php ./bin/cli.php route:list --method=post --name=register, which returns the account.register route mapped to /account/register.
+A: By combining the method and name filters: `php ./bin/cli.php route:list --method=post --name=register`, which returns the account.register route mapped to /account/register.
 
 **Q: How do you get more help on this command?**
-A: Run php ./bin/cli.php route:list --help to get more information about the command.
+A: Run `php ./bin/cli.php route:list --help` to get more information about the command.
diff --git a/public/md-articles/how-to/migrating-dotkernel-3-from-zend-expressive-2-to-zend-expressive-3.md b/public/md-articles/how-to/migrating-dotkernel-3-from-zend-expressive-2-to-zend-expressive-3.md
index 093bc5a1..9bed1a20 100644
--- a/public/md-articles/how-to/migrating-dotkernel-3-from-zend-expressive-2-to-zend-expressive-3.md
+++ b/public/md-articles/how-to/migrating-dotkernel-3-from-zend-expressive-2-to-zend-expressive-3.md
@@ -11,39 +11,16 @@ language: "en"
 # Migrating Dotkernel 3 from Zend Expressive 2 to Zend Expressive 3
 
 ## TL;DR
+
 This guide covers migrating a Dotkernel 3 instance from Zend Expressive 2 to Zend Expressive 3, for projects that only contain controller-based middleware.
 Old middleware must first be refactored to the `psr/http-server-middleware` interfaces, since Delegates become RequestHandlers.
 The steps then cover updating `composer.json` dependencies, registering new ConfigProviders, wrapping `routes.php` and `pipeline.php` in callables, and replacing the old `pipeRoutingMiddleware()`/`pipeDispatchMiddleware()` calls with their PSR-15 equivalents.
 
-This article covers the steps required to migrate a Dotkernel 3 instance to the latest Zend Expressive Version.
-
-**Migration from Zend Expressive 2 to 3.**
-
- 
-
-*Notes before starting:*
-
-For a better understanding of the migration and how it affects support we recommend reading Zend Expressive's [article](https://docs.zendframework.com/zend-expressive/v3/reference/migration/#http-interop) on migration.
-
-If your project contains old middleware it must be refactored to reflect the interfaces provided in the [**psr/http-server-middleware**](https://packagist.org/packages/psr/http-server-middleware) package.
-
-By updating your middleware the **Delegate**s will become **RequestHandler**s**. **The interfaces are provided in the **[psr/http-server-handler](https://packagist.org/packages/psr/http-server-handler) **package.
-
- 
-
-If your project only contains controller-based middleware it can be migrated by following the guides below.
-
- 
-
-## Dotkernel3 Migration - Expressive 2.0 -> 3.0
-
- 
-
 ## Packages
 
-In `composer.json` replace the matching repositories with the following:
+In `composer.json` replace the matching repositories with the following:
 
-```
+```json
 "dotkernel/dot-authentication-service":"^1.0",
 "dotkernel/dot-authentication-service":"^1.0",
 "dotkernel/dot-authentication-web":"^1.0.1",
@@ -83,25 +60,25 @@ In `composer.json` replace the matching repositories with the following:
 "zendframework/zend-component-installer":"^2.0
 ```
 
-also update require-dev dependencies
+Also update require-dev dependencies:
 
-```
+```json
 "zendframework/zend-expressive-tooling:": "^1.0",
 "zendframework/zend-component-installer": "^2.0",
 ```
 
 Remove packages:
 
-- http-interop/http-middleware
-- webimpress/http-middleware-compatibility
+- `http-interop/http-middleware`
+- `webimpress/http-middleware-compatibility`
 
 ## Configurations
 
 ### Main Configuration
 
-In `config/config.php` add the following config providers:
+In `config/config.php` add the following config providers:
 
-```
+```php
 // zend expressive & middleware factory
 \Zend\Expressive\ConfigProvider::class,
 
@@ -116,22 +93,22 @@ In `config/config.php` add the following config providers:
 \Zend\HttpHandlerRunner\ConfigProvider::class,
 ```
 
-Make sure they are the first ConfigProviders or before cached config (`ArrayProvider`)
+Make sure they are the first ConfigProviders or before cached config (`ArrayProvider`).
 
 ### Routing
 
-Wrap routing from `config/routes.php` in a callable with the following format:
+Wrap routing from `config/routes.php` in a callable with the following format:
 
-```
+```php
 return function (Application $app, MiddlewareFactory $factory, ContainerInterface $container) : void {
     /** @var \Zend\Expressive\Application $app */
     $app->route('/', , , 'home');
 };
 ```
 
-add the following use statements and make sure the names are not duplicate:
+Add the following use statements and make sure the names are not duplicate:
 
-```
+```php
 use Psr\Container\ContainerInterface;
 use Zend\Expressive\Application;
 use Zend\Expressive\MiddlewareFactory;
@@ -139,43 +116,41 @@ use Zend\Expressive\MiddlewareFactory;
 
 ### Pipeline
 
-Wrap routing from `config/pipeline.php` in a callable with the following format:
+Wrap routing from `config/pipeline.php` in a callable with the following format:
 
-```
+```php
 return function (Application $app, MiddlewareFactory $factory, ContainerInterface $container) : void {
     /** @var \Zend\Expressive\Application $app */
     $app->route('/', , , 'home');
 };
 ```
 
-add the following use statements and make sure the names are not duplicate:
+Add the following use statements and make sure the names are not duplicate:
 
-```
+```php
 use Psr\Container\ContainerInterface;
 use Zend\Expressive\Application;
 use Zend\Expressive\MiddlewareFactory;
 ```
 
-#### Routing middleware migration
+#### Routing Middleware Migration
 
-add the following use statements
+Add the following use statements:
 
-```
+```php
 use Zend\Expressive\Router\Middleware\RouteMiddleware;
 use Zend\Expressive\Router\Middleware\DispatchMiddleware;
 ```
 
 Replace the following lines to reflect the changes:
 
-`$app->pipeRoutingMiddleware();` -> `$app->pipe(RouteMiddleware::class);` `$app->pipeDispatchMiddleware();` -> `$app->pipe(DispatchMiddleware::class);`
-
- 
-
-You can check the complete guides and example files from the following links
+- `$app->pipeRoutingMiddleware();` becomes `$app->pipe(RouteMiddleware::class);`
+- `$app->pipeDispatchMiddleware();` becomes `$app->pipe(DispatchMiddleware::class);`
 
-**Migration guide for Dotkernel Frontend:** [github.com/dotkernel/frontend/tree/master/docs](https://github.com/dotkernel/frontend/tree/master/docs)
+You can check the complete guides and example files from the following links:
 
-**Migration guide for Dotkernel Admin:** [docs.dotkernel.org/admin-documentation](https://docs.dotkernel.org/admin-documentation/) (the old `github.com/dotkernel/admin/tree/master/docs` folder has since moved to this documentation site)
+- [Migration guide for Dotkernel Frontend](https://github.com/dotkernel/frontend/tree/master/docs)
+- [Migration guide for Dotkernel Admin](https://docs.dotkernel.org/admin-documentation/) (the old `github.com/dotkernel/admin/tree/master/docs` folder has since moved to this documentation site)
 
 ## FAQ
 
@@ -183,16 +158,17 @@ You can check the complete guides and example files from the following links
 A: For a better understanding of the migration and how it affects support, it's recommended to read Zend Expressive's article on migration regarding HTTP interop.
 
 **Q: What happens to old middleware during the migration?**
-A: If a project contains old middleware, it must be refactored to reflect the interfaces provided in the psr/http-server-middleware package. As part of this, Delegates become RequestHandlers, using interfaces from the psr/http-server-handler package.
+A: If a project contains old middleware, it must be refactored to reflect the interfaces provided in the psr/http-server-middleware package.
+As part of this, Delegates become RequestHandlers, using interfaces from the psr/http-server-handler package.
 
 **Q: Which packages should be removed during migration?**
-A: http-interop/http-middleware and webimpress/http-middleware-compatibility should be removed from composer.json.
+A: `http-interop/http-middleware` and `webimpress/http-middleware-compatibility` should be removed from `composer.json`.
 
 **Q: What needs to be added to the main configuration file?**
-A: In config/config.php, several ConfigProviders need to be added – for Zend Expressive, the router, FastRoute router, Twig, helpers, and the handler runner – and they must be the first ConfigProviders or placed before the cached config (ArrayProvider).
+A: In `config/config.php`, several ConfigProviders need to be added - for Zend Expressive, the router, FastRoute router, Twig, helpers, and the handler runner - and they must be the first ConfigProviders or placed before the cached config (`ArrayProvider`).
 
 **Q: How do the routes.php and pipeline.php files change?**
-A: Routing from config/routes.php and the pipeline from config/pipeline.php both need to be wrapped in a callable of the form function (Application $app, MiddlewareFactory $factory, ContainerInterface $container), with the corresponding use statements added.
+A: Routing from `config/routes.php` and the pipeline from `config/pipeline.php` both need to be wrapped in a callable of the form `function (Application $app, MiddlewareFactory $factory, ContainerInterface $container)`, with the corresponding use statements added.
 
 **Q: What replaces pipeRoutingMiddleware() and pipeDispatchMiddleware()?**
-A: $app->pipeRoutingMiddleware(); becomes $app->pipe(RouteMiddleware::class);, and $app->pipeDispatchMiddleware(); becomes $app->pipe(DispatchMiddleware::class);.
+A: `$app->pipeRoutingMiddleware();` becomes `$app->pipe(RouteMiddleware::class);`, and `$app->pipeDispatchMiddleware();` becomes `$app->pipe(DispatchMiddleware::class);`.
diff --git a/public/md-articles/how-to/replacing-dot-console-with-dot-cli-based-on-laminas-cli.md b/public/md-articles/how-to/replacing-dot-console-with-dot-cli-based-on-laminas-cli.md
index eca79a0c..bc462e01 100644
--- a/public/md-articles/how-to/replacing-dot-console-with-dot-cli-based-on-laminas-cli.md
+++ b/public/md-articles/how-to/replacing-dot-console-with-dot-cli-based-on-laminas-cli.md
@@ -11,73 +11,87 @@ language: "en"
 # Replacing dot-console with dot-cli based on laminas-cli
 
 ## TL;DR
+
 Dotkernel's dot-cli package replaces dot-console, which was abandoned after Laminas dropped the laminas-console package it was based on.
 Setting it up involves requiring the package via Composer, registering its ConfigProvider, and copying its bootstrap and config files into the application.
 It also ships with FileLocker, a built-in, enabled-by-default locking system that prevents overlapping calls to the same command.
 
-## Replacing dot-console with dot-cli based on laminas-cli
-
-## Implementing dot-cli in your application
+## Implementing dot-cli in Your Application
 
 Dotkernel's [dot-cli](https://github.com/dotkernel/dot-cli) package comes as a replacement for [dot-console](https://github.com/dotkernel/dot-console), which was abandoned after Laminas abandoned their [laminas-console](https://github.com/laminas/laminas-console) package, that dot-console was based on.
 
 ## Setup
 
-### Install package
+### Install Package
 
 Run the following command in your application's root directory:
 
-```
+```bash
 composer require dotkernel/dot-cli
 ```
 
 ### Register ConfigProvider
 
-Open your application's **config/config.php** file and add `Dot\Cli\ConfigProvider::class,` under the *DK packages* comment.
+Open your application's `config/config.php` file and add `Dot\Cli\ConfigProvider::class,` under the DK packages comment.
 
-### Create bootstrap file
-
-Locate the provided **vendor/dotkernel/dot-cli/bin/cli.php** and copy it into your application's **bin** directory.
+### Create Bootstrap File
 
+Locate the provided `vendor/dotkernel/dot-cli/bin/cli.php` and copy it into your application's `bin` directory.
 This is the file you will execute your commands through.
 
-### Create config file
-
-Locate the provided **vendor/dotkernel/dot-cli/config/autoload/cli.global.php** and copy it into your application's **config/autoload** directory.
+### Create Config File
 
-This file already contains a sample command (**demo:command**), that serves as an example on creating an registering new commands.
-
-For more information on configuring/chaining commands, see [laminas-cli documentation](https://docs.laminas.dev/laminas-cli/).
+Locate the provided `vendor/dotkernel/dot-cli/config/autoload/cli.global.php` and copy it into your application's `config/autoload` directory.
+This file already contains a sample command (`demo:command`), that serves as an example on creating and registering new commands.
+For more information on configuring/chaining commands, see the [laminas-cli documentation](https://docs.laminas.dev/laminas-cli/).
 
 ## Usage
 
 Run the following command in your application's root directory:
 
-```
+```bash
 php ./bin/cli.php
 ```
 
 The output should look similar to this, containing information on how to start using dot-cli:
 
 ```
-Dotkernel CLI 1.0.0Usage:  command  Options:  -h, --help            Display help for the given command. When no command is given display help for the list command  -q, --quiet           Do not output any message  -V, --version         Display this application version      --ansi            Force ANSI output      --no-ansi         Disable ANSI output  -n, --no-interaction  Do not ask any interactive question  -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debugAvailable commands:  help          Display help for a command  list          List commands demo  demo:command  Demo command description.
+Dotkernel CLI 1.0.0
+
+Usage:
+  command
+
+Options:
+  -h, --help            Display help for the given command. When no command is given display help for the list command
+  -q, --quiet           Do not output any message
+  -V, --version         Display this application version
+      --ansi            Force ANSI output
+      --no-ansi         Disable ANSI output
+  -n, --no-interaction  Do not ask any interactive question
+  -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug
+
+Available commands:
+  help          Display help for a command
+  list          List commands
+ demo
+  demo:command  Demo command description.
 ```
 
-## Set up command as cronjob
+## Set Up Command as Cronjob
 
 Open your crontab and add the following line:
 
-```
+```bash
 * * * * {PATH_TO_PHP_EXECUTABLE} {PATH_TO_APPLICATION}/bin/cli.php demo:command
 ```
 
-Where *{PATH_TO_PHP_EXECUTABLE}* needs to replaced with the full path to the PHP executable and *{PATH_TO_APPLICATION}* with the full path to your application's root directory.
+Where {PATH_TO_PHP_EXECUTABLE} needs to be replaced with the full path to the PHP executable and {PATH_TO_APPLICATION} with the full path to your application's root directory.
 
 ## FileLocker
 
-dot-cli has a built-in locking system, called FileLocker, enabled by default. This feature prevents multiple calls to the same command overlapping eachother by making sure the latter calls won't run until the former one is finished.
-
-You can toggle this modifying in the previously created **config/autoload/cli.global.php** under `FileLockerInterface::class -> enabled`
+dot-cli has a built-in locking system, called FileLocker, enabled by default.
+This feature prevents multiple calls to the same command overlapping each other by making sure the latter calls won't run until the former one is finished.
+You can toggle this by modifying the previously created `config/autoload/cli.global.php` under `FileLockerInterface::class -> enabled`.
 
 ## FAQ
 
@@ -85,13 +99,14 @@ You can toggle this modifying in the previously created **config/autoload/cli.gl
 A: dot-console was abandoned after Laminas abandoned its laminas-console package, which dot-console was based on, so dot-cli was created as its replacement.
 
 **Q: How do you install dot-cli in an application?**
-A: Run composer require dotkernel/dot-cli in the application's root directory, then register Dot\Cli\ConfigProvider::class, in config/config.php, and copy the provided bin/cli.php bootstrap file and config/autoload/cli.global.php config file into the application.
+A: Run `composer require dotkernel/dot-cli` in the application's root directory, then register `Dot\Cli\ConfigProvider::class,` in `config/config.php`, and copy the provided `bin/cli.php` bootstrap file and `config/autoload/cli.global.php` config file into the application.
 
 **Q: What does the provided cli.global.php config file contain?**
-A: It already contains a sample command (demo:command) that serves as an example on how to create and register new commands.
+A: It already contains a sample command (`demo:command`) that serves as an example on how to create and register new commands.
 
 **Q: How do you run a dot-cli command as a cronjob?**
-A: Add a line to your crontab such as * * * * {PATH_TO_PHP_EXECUTABLE} {PATH_TO_APPLICATION}/bin/cli.php demo:command, replacing the placeholders with the full path to the PHP executable and the full path to the application's root directory.
+A: Add a line to your crontab such as `* * * * {PATH_TO_PHP_EXECUTABLE} {PATH_TO_APPLICATION}/bin/cli.php demo:command`, replacing the placeholders with the full path to the PHP executable and the full path to the application's root directory.
 
 **Q: What is FileLocker?**
-A: FileLocker is a built-in locking system in dot-cli, enabled by default, that prevents multiple calls to the same command from overlapping by making sure later calls won't run until the earlier one finishes. It can be toggled in config/autoload/cli.global.php under FileLockerInterface::class -> enabled.
+A: FileLocker is a built-in locking system in dot-cli, enabled by default, that prevents multiple calls to the same command from overlapping by making sure later calls won't run until the earlier one finishes.
+It can be toggled in `config/autoload/cli.global.php` under `FileLockerInterface::class -> enabled`.
diff --git a/public/md-articles/how-to/using-postman-for-documentation-in-dotkernel-api-3.md b/public/md-articles/how-to/using-postman-for-documentation-in-dotkernel-api-3.md
index eef018de..80efb25a 100644
--- a/public/md-articles/how-to/using-postman-for-documentation-in-dotkernel-api-3.md
+++ b/public/md-articles/how-to/using-postman-for-documentation-in-dotkernel-api-3.md
@@ -11,14 +11,14 @@ language: "en"
 # Using Postman for documentation in Dotkernel API 3
 
 ## TL;DR
+
 Starting from version 3.0, Dotkernel API documents its endpoints using Postman, via a provided collection and environment file that get imported into the tool.
 Postman organizes work into a Workspace, Collections, Environments, and Requests, and the Dotkernel API collection ships with built-in security: global Bearer Token authorization inherited from the collection root, and automatic ACCESS_TOKEN/REFRESH_TOKEN storage on the Admin/Security and User/Security folders.
 After making changes, the collection and environment files can be re-exported to overwrite the application's documentation files.
 
-## Using Postman documentation in Dotkernel API 3
-
-Starting from version 3.0 Dotkernel API provides it's documentation using [Postman](https://www.postman.com/).
+## Using Postman Documentation in Dotkernel API 3
 
+Starting from version 3.0 Dotkernel API provides its documentation using [Postman](https://www.postman.com/).
 In this article we will go into the details of creating and maintaining your application's documentation.
 
 ## Prerequisites
@@ -26,30 +26,31 @@ In this article we will go into the details of creating and maintaining your app
 In order to follow the steps, you will need the following:
 
 - a working installation of Dotkernel API 3
-- download and install Postman from their [download page](https://www.postman.com/downloads/).
+- download and install Postman from their [download page](https://www.postman.com/downloads/)
 
-**TIP:** If you don't have a Postman account, we recommend you to create one. This way Postman is able to backup your workspace in the cloud and synchronize it across multiple devices.
+TIP: If you don't have a Postman account, we recommend you to create one.
+This way Postman is able to backup your workspace in the cloud and synchronize it across multiple devices.
 
 ## Introduction
 
 For better understanding on how Postman works, we need to run through the "building blocks" of Postman:
 
-- **Workspace**: is the main container that holds all your collections, APIs, environments etc
-- **Collection**: holds all requests and dependencies of a project (for example Dotkernel API's collection containing all requests)
-- **Environment**: holds a set of environment-specific variables (for example Dotkernel API's environment file cotaining the application URL specific to the development environment)
-- **Request**: the definition of an API endpoint, including request method, name, description, URL, body, parameters and an example
+- Workspace: is the main container that holds all your collections, APIs, environments etc
+- Collection: holds all requests and dependencies of a project (for example Dotkernel API's collection containing all requests)
+- Environment: holds a set of environment-specific variables (for example Dotkernel API's environment file containing the application URL specific to the development environment)
+- Request: the definition of an API endpoint, including request method, name, description, URL, body, parameters and an example
 
-There are more terms to cover, like *Mock servers*, *Monitors* etc but they are not relevant yet in our case.
+There are more terms to cover, like Mock servers, Monitors etc but they are not relevant yet in our case.
 
-### Importing documentation files
+### Importing Documentation Files
 
 Open Postman (and log in if you have an account), then follow the below steps:
 
 - open the import modal by clicking `File` -> `Import` (or `Ctrl + O`)
 - inside the modal, make sure you're on the `File` tab, then click `Upload files`
 - navigate to `documentation` directory of your Dotkernel API 3 application and select both of the following files:
-  - **Dotkernel_API.postman_collection.json**
-  - **Dotkernel_API.postman_environment.json**
+  - Dotkernel_API.postman_collection.json
+  - Dotkernel_API.postman_environment.json
 - after clicking `Open` the modal should show the following:
 
 ```
@@ -61,17 +62,17 @@ Dotkernel_API        Postman Environment            Environment
 
 - at the bottom of the import modal, clicking `Import` will import the selected files and close the modal.
 
-Under **My Workspace** you should see a tab called **Collections**. Clicking on it should display all your collections, one of them called `Dotkernel_API`. This collection holds all of the provided requests and serves as the documentation of your application.
-
-Dotkernel API 3 collection and environment files ar now imported and ready to use.
-
+Under My Workspace you should see a tab called Collections.
+Clicking on it should display all your collections, one of them called `Dotkernel_API`.
+This collection holds all of the provided requests and serves as the documentation of your application.
+Dotkernel API 3 collection and environment files are now imported and ready to use.
 For more information on importing files into Postman, please consult their [docs](https://learning.postman.com/docs/getting-started/importing-and-exporting-data/).
 
-### Interacting with the environment
-
-On the top right corner of Postman, you'll see the **Environment quick look** button (it looks like an eye). On it's left side, there's a dropdown with all available environments, one of the being called `Dotkernel_API` - click on it to set it as the active environment.
+### Interacting with the Environment
 
-After this, clicking the **Environment quick look** button will bring up a modal containing all variables found in the environment:
+On the top right corner of Postman, you'll see the Environment quick look button (it looks like an eye).
+On its left side, there's a dropdown with all available environments, one of them being called `Dotkernel_API` - click on it to set it as the active environment.
+After this, clicking the Environment quick look button will bring up a modal containing all variables found in the environment:
 
 ```
 Dotkernel_API                                                                              Edit
@@ -79,56 +80,58 @@ VARIABLE               INITIAL VALUE                CURRENT_VALUE
 APPLICATION_URL        http://localhost:8080        http://localhost:8080
 ```
 
-If your application runs on a different host/port, click the **Edit** button to modify the initial/current value of the `APPLICATION_URL` variable.
-
-Once in Edit mode, you can also create new variables. You only have to enter the variable name and it's initial value - current value will be automatically filled in when the variable is used.
+If your application runs on a different host/port, click the Edit button to modify the initial/current value of the `APPLICATION_URL` variable.
+Once in Edit mode, you can also create new variables.
+You only have to enter the variable name and its initial value - current value will be automatically filled in when the variable is used.
 
 ## Usage
 
-### Creating a new request
+### Creating a New Request
 
-Inside the collection, right-click on any folder and click `Add Request`. The new request is automatically opened in a new tab, where you will:
+Inside the collection, right-click on any folder and click `Add Request`.
+The new request is automatically opened in a new tab, where you will:
 
-- enter request name by replacing *New Request* with a short and descriptive name
-- enter request description (first button under the **Environment quick look** button)
-- enter request URL - you should use the already existing variable `APPLICATION_URL` by wrapping it in double curly braces, then append the request path. Example: `{{ APPLICATION_URL }}/test` becomes `http://localhost:8080/test` when you send the request.
+- enter request name by replacing New Request with a short and descriptive name
+- enter request description (first button under the Environment quick look button)
+- enter request URL - you should use the already existing variable `APPLICATION_URL` by wrapping it in double curly braces, then append the request path.
+Example: `{{ APPLICATION_URL }}/test` becomes `http://localhost:8080/test` when you send the request.
 - select request method
 - (optionally) inspect tabs:
-  - **Params**: manage query parameters
-  - **Authorization**: select authorization type
-  - **Headers**: manage request headers
-  - **Body**: manage request body
-  - **Pre-request script**: provide *JavaScript* that Postman should run before sending the request
-  - **Tests**: provide *JavaScript* that Postman should run after receiving the response
-  - **Settings**: manage miscellaneous request settings
-- save the request using the **Save** button (or `Ctrl + S`)
-
-### Sending a request
+  - Params: manage query parameters
+  - Authorization: select authorization type
+  - Headers: manage request headers
+  - Body: manage request body
+  - Pre-request script: provide JavaScript that Postman should run before sending the request
+  - Tests: provide JavaScript that Postman should run after receiving the response
+  - Settings: manage miscellaneous request settings
+- save the request using the Save button (or `Ctrl + S`)
 
-Once opened, you can immediately send a request by clicking the **Send** button.
+### Sending a Request
 
-Optionally, you can save the response as an example (click on **Save Response**, then select **Save as example**), so other developers will have a visual representation of the response without making a request. This opens a new tab, where you can manage the example.
+Once opened, you can immediately send a request by clicking the Send button.
+Optionally, you can save the response as an example (click on Save Response, then select Save as example), so other developers will have a visual representation of the response without making a request.
+This opens a new tab, where you can manage the example.
 
 ## Features
 
 The collection provided by Dotkernel API 3 comes with some built-in security features.
 
-### Global security
+### Global Security
 
-Due to the hierarchy of the Collection, all requests are children of the Collection's root folder, so they automatically inherit it's Authorization settings. If you edit the Collection's root folder, you will find the following tabs:
+Due to the hierarchy of the Collection, all requests are children of the Collection's root folder, so they automatically inherit its Authorization settings.
+If you edit the Collection's root folder, you will find the following tabs:
 
-- **Authorization**
-  - **Type** is set to `Bearer Token`
-  - **Token** reads the environment variable `ACCESS_TOKEN`
-- **Pre-request Script**: here you can add *JavaScript* that should run on ALL requests before they run
-- **Tests**: here you can add *JavaScript* that should run on ALL requests after their response is returned
-- **Variables**: here you can manage global variables
+- Authorization
+  - Type is set to `Bearer Token`
+  - Token reads the environment variable `ACCESS_TOKEN`
+- Pre-request Script: here you can add JavaScript that should run on ALL requests before they run
+- Tests: here you can add JavaScript that should run on ALL requests after their response is returned
+- Variables: here you can manage global variables
 
-To disable this feature globally, set Authorization **Type** to `No Auth` or whatever value suits your application's requirements.
+To disable this feature globally, set Authorization Type to `No Auth` or whatever value suits your application's requirements.
+To disable this feature at folder/request level, edit the folder/request and set Type to `No Auth` under the Authorization tab.
 
-To disable this feature at folder/request level, edit the folder/request and set **Type** to `No Auth` under the Authorization tab.
-
-### Automatic Token storage
+### Automatic Token Storage
 
 Once an authorization token is re/generated, two environment variables are set/updated:
 
@@ -137,22 +140,28 @@ Once an authorization token is re/generated, two environment variables are set/u
 
 This is achieved by applying the following modifications to both Admin/Security and User/Security folders:
 
-- setting **Type** to `No Auth` under the **Authorization** tab (because the child requests under these folders should not send Authorization header)
-- adding a script under the **Tests** tab, that reads the response and - if successful - set/updates the above mentioned environment variables
-
-## Exporting documentation
+- setting Type to `No Auth` under the Authorization tab (because the child requests under these folders should not send Authorization header)
+- adding a script under the Tests tab, that reads the response and - if successful - set/updates the above mentioned environment variables
 
-**TIP**: You can inspect your application's documentation at any moment by clicking on the *three horizontal dots* (you will find them on hover next to your collection's name) then click on **View documentation**.
+## Exporting Documentation
 
-### Exporting collection
+TIP: You can inspect your application's documentation at any moment by clicking on the three horizontal dots (you will find them on hover next to your collection's name) then click on View documentation.
 
-Click on the same *three horizontal dots*, then select **Export**. You will be presented an *Export collection* modal asking you to choose the format of the export. Unless specified, choose the recommended version, then click **Export**. When asked to save the exported file, choose to overwrite your application's collection file (*documentaion/Dotkernel_API.postman_collection.json*).
+### Exporting Collection
 
-### Export environment
+Click on the same three horizontal dots, then select Export.
+You will be presented an Export collection modal asking you to choose the format of the export.
+Unless specified, choose the recommended version, then click Export.
+When asked to save the exported file, choose to overwrite your application's collection file (documentation/Dotkernel_API.postman_collection.json).
 
-This step is optional. It is needed only if you made modifications to the environment, else you can skip it.
+### Export Environment
 
-Start by clicking on the **Environment quick look** button, then click **Edit**. Once the edit environment tab opens, locate the *three horizontal dots* next to the **Share** button on the right of the Postman window. Click them and select **Export**. When asked to save the exported file, choose to overwrite your application's environment file (*documentaion/Dotkernel_API.postman_environment.json*).
+This step is optional.
+It is needed only if you made modifications to the environment, else you can skip it.
+Start by clicking on the Environment quick look button, then click Edit.
+Once the edit environment tab opens, locate the three horizontal dots next to the Share button on the right of the Postman window.
+Click them and select Export.
+When asked to save the exported file, choose to overwrite your application's environment file (documentation/Dotkernel_API.postman_environment.json).
 
 ## FAQ
 
@@ -160,13 +169,14 @@ Start by clicking on the **Environment quick look** button, then click **Edit**.
 A: Workspace (the main container holding all collections, APIs and environments), Collection (holds all requests and dependencies of a project, such as Dotkernel API's collection), Environment (holds environment-specific variables, like the application URL), and Request (the definition of an API endpoint, including method, name, description, URL, body, parameters and an example).
 
 **Q: How do you import Dotkernel API's documentation files into Postman?**
-A: Open the import modal via File -> Import (or Ctrl + O), go to the File tab, click Upload files, then select both Dotkernel_API.postman_collection.json and Dotkernel_API.postman_environment.json from the application's documentation directory, and click Import.
+A: Open the import modal via `File -> Import` (or `Ctrl + O`), go to the `File` tab, click `Upload files`, then select both `Dotkernel_API.postman_collection.json` and `Dotkernel_API.postman_environment.json` from the application's `documentation` directory, and click `Import`.
 
 **Q: What variable controls which host/port the requests target?**
-A: The APPLICATION_URL environment variable, found under the Dotkernel_API environment, defaults to http://localhost:8080 and can be edited via the Environment quick look button if the application runs on a different host/port.
+A: The `APPLICATION_URL` environment variable, found under the `Dotkernel_API` environment, defaults to `http://localhost:8080` and can be edited via the Environment quick look button if the application runs on a different host/port.
 
 **Q: What built-in security features does the collection provide?**
-A: Global security: all requests inherit Bearer Token authorization (reading the ACCESS_TOKEN environment variable) from the Collection's root folder, which can be disabled globally or per folder/request. Automatic token storage: the Admin/Security and User/Security folders use Test scripts to set/update the ACCESS_TOKEN and REFRESH_TOKEN environment variables whenever a token is re/generated.
+A: Global security: all requests inherit Bearer Token authorization (reading the `ACCESS_TOKEN` environment variable) from the Collection's root folder, which can be disabled globally or per folder/request.
+Automatic token storage: the Admin/Security and User/Security folders use Test scripts to set/update the `ACCESS_TOKEN` and `REFRESH_TOKEN` environment variables whenever a token is re/generated.
 
 **Q: How do you export the collection after making changes?**
 A: Click the three horizontal dots next to the collection's name, select Export, choose the recommended format, click Export, and overwrite the application's collection file (documentation/Dotkernel_API.postman_collection.json).
diff --git a/public/md-articles/how-to/using-the-urlgenerator-work-in-fastroute.md b/public/md-articles/how-to/using-the-urlgenerator-work-in-fastroute.md
index 369bbca4..2deb2f0e 100644
--- a/public/md-articles/how-to/using-the-urlgenerator-work-in-fastroute.md
+++ b/public/md-articles/how-to/using-the-urlgenerator-work-in-fastroute.md
@@ -11,55 +11,52 @@ language: "en"
 # Using the URLGenerator work in FastRoute
 
 ## TL;DR
+
 Dotkernel 3 uses FastRoute under the hood, which is fast but has a quirk around slash-suffixes that a wrong route setup can trigger, leading to hard-to-diagnose errors.
 Optional slashes must be kept inside the optional block of a route definition, or the URLGenerator ends up producing the wrong route.
 Every named route can then be referenced instead of hard-coded, using `$this->url()` in controllers or the `path()` function in Twig views.
 
-Dotkernel 3 uses `FastRoute` under the hood, which is an excellent and fast routing package, but it does have some **quirks**.
-
-A wrong setup can lead to many headaches, as it's not prominent that the error you're experiencing is from FastRoute, and you may not know where exactly to look for the cause.
-
-To save you some time, here's a how-to for creating and using routes in `Dotkernel 3`.
+## Declaring Routes
 
-## Declaring routes
+When defining routes in the `routes.php` file, they need to follow a specific pattern, a usual route would look like this:
 
-When defining routes in the *routes.php* file, they need to follow a specific pattern, a usual route would look like this:
-
-```
+```php
 $app->route('/page', , , 'page');
 ```
 
-> Notice the *'***/page***'* part, as this is crucial. FastRoute cannot handle a *slash-suffix*, which means that **/page** will give you the indexAction, whereas **/page/** will give you a 404.
+> Notice the '/page' part, as this is crucial. FastRoute cannot handle a slash-suffix, which means that /page will give you the indexAction, whereas /page/ will give you a 404.
 
-To prevent the URLGenerator from adding a slash-suffix, we need to make sure that the optional slash is included in the optional block. **The above example is correct**, if we instead wrote it like this, it'd be woefully bad.
+To prevent the URLGenerator from adding a slash-suffix, we need to make sure that the optional slash is included in the optional block.
+The above example is correct; if we instead wrote it like this, it'd be woefully bad:
 
-```
+```php
 $app->route('/page/', , , 'page');
 ```
 
-> Notice that the slash has changed places and is now outside the optional block. This would generate a **/page/** route for the index action, which is bad, so always include any optional parts, even slashes, in the optional block.
+> Notice that the slash has changed places and is now outside the optional block. This would generate a /page/ route for the index action, which is bad, so always include any optional parts, even slashes, in the optional block.
 
-## Referencing routes
+## Referencing Routes
 
-Developers are used to hand-write and hard-code URLs into anchor tags, but this is a bad idea, as a URL may change and then you'd have to go through the entire app to find every single reference for it. Instead, every route we define has a name that can be used to reference it in the URLGenerator.
+Developers are used to hand-write and hard-code URLs into anchor tags, but this is a bad idea, as a URL may change and then you'd have to go through the entire app to find every single reference for it.
+Instead, every route we define has a name that can be used to reference it in the URLGenerator.
 
-```
+```php
 $app->route('/page', , , 'page');
 ```
 
 > That very last part there, that's the route name, which can be referenced in any view or controller to generate a route to a specific route in the app.
 
-To use it in a Controller, you have access to `$this->url();` which takes the route name, in this case, '**page**', as the first parameter, and then any optional blocks as the second parameter.
-
+To use it in a controller, you have access to `$this->url();`, which takes the route name, in this case, 'page', as the first parameter, and then any optional blocks as the second parameter.
 A controller redirect may then look like this:
 
-```
+```php
 return new RedirectResponse($this->url('contact', ['action' => 'thank-you']));
 ```
 
 Using the URLGenerator in views is approximately the same, since you have access to the global `path()` method.
-
-The path method works the same way as the `url()` method, and takes the route name as the first parameter, and any optional blocks as its second parameter. This is of course done in `Twig`, so we need to put curly brackets around it since it's dynamic and not static HTML. It could look like this:
+The path method works the same way as the `url()` method, and takes the route name as the first parameter, and any optional blocks as its second parameter.
+This is of course done in Twig, so we need to put curly brackets around it since it's dynamic and not static HTML.
+It could look like this:
 
 ```
 {{ path(name: 'page', parameters: {action: 'thank-you'}, relative: false) }}
@@ -68,13 +65,15 @@ The path method works the same way as the `url()` method, and takes the route na
 ## FAQ
 
 **Q: What is a common quirk to watch out for when declaring routes in FastRoute?**
-A: FastRoute cannot handle a slash-suffix: for a route defined as /page, requesting /page works, but /page/ gives a 404. Any optional part, including slashes, needs to be included inside the optional block, not appended outside it – otherwise the URLGenerator ends up producing the wrong route for the index action.
+A: FastRoute cannot handle a slash-suffix: for a route defined as `/page`, requesting /page works, but /page/ gives a 404.
+Any optional part, including slashes, needs to be included inside the optional block, not appended outside it - otherwise the URLGenerator ends up producing the wrong route for the index action.
 
 **Q: Why should route names be used instead of hard-coded URLs?**
-A: Hand-writing and hard-coding URLs into anchor tags is a bad idea because a URL may change and then every reference throughout the app would need to be updated. Instead, every defined route has a name that can be referenced through the URLGenerator.
+A: Hand-writing and hard-coding URLs into anchor tags is a bad idea because a URL may change and then every reference throughout the app would need to be updated.
+Instead, every defined route has a name that can be referenced through the URLGenerator.
 
 **Q: How do you generate a URL from a route name inside a controller?**
-A: Use $this->url(), passing the route name as the first parameter and any optional blocks as the second parameter, for example in a redirect: return new RedirectResponse($this->url('contact'));.
+A: Use `$this->url()`, passing the route name as the first parameter and any optional blocks as the second parameter, for example in a redirect: `return new RedirectResponse($this->url('contact'));`.
 
 **Q: How do you generate a URL from a route name inside a Twig view?**
-A: Use the global path() function, which works the same way as url(), taking the route name as the first parameter and any optional blocks as the second parameter, wrapped in curly brackets since it's dynamic Twig code.
+A: Use the global `path()` function, which works the same way as `url()`, taking the route name as the first parameter and any optional blocks as the second parameter, wrapped in curly brackets since it's dynamic Twig code.
diff --git a/public/md-articles/how-to/what-is-cross-origin-token-redemption.md b/public/md-articles/how-to/what-is-cross-origin-token-redemption.md
index efc413b5..d926c496 100644
--- a/public/md-articles/how-to/what-is-cross-origin-token-redemption.md
+++ b/public/md-articles/how-to/what-is-cross-origin-token-redemption.md
@@ -11,31 +11,38 @@ language: "en"
 # What is cross origin token redemption?
 
 ## TL;DR
+
 Cross-origin token redemption verifies the security and authenticity of a token issued on one domain but used on another, which is common when a logged-in user needs to access resources on a different site.
 The receiving domain checks the token's signature and decrypts it before trusting it.
 JWT and OAuth 2.0 are two standards that implement this pattern, each with a different verification flow.
 
-## What is cross origin token redemption?
-
-Cross-origin token redemption is a technique used to ensure the security and authenticity of a token that is issued by one website or domain, but intended for use on a different website or domain. This process is commonly used in situations where a user needs to access resources from multiple domains, such as when a user is logged in to one website and needs to access resources from another website.
-
-When a token is issued from one domain, it is typically encrypted and signed to prevent tampering and ensure that it can only be used by the intended recipient. When the token is redeemed on a different domain, the receiving domain must first verify the authenticity of the token by checking the signature and decrypting the token.
+Cross-origin token redemption is a technique used to ensure the security and authenticity of a token that is issued by one website or domain, but intended for use on a different website or domain.
+This process is commonly used in situations where a user needs to access resources from multiple domains, such as when a user is logged in to one website and needs to access resources from another website.
+When a token is issued from one domain, it is typically encrypted and signed to prevent tampering and ensure that it can only be used by the intended recipient.
+When the token is redeemed on a different domain, the receiving domain must first verify the authenticity of the token by checking the signature and decrypting the token.
 
-### **JSON Web Token (JWT)**
+## JSON Web Token (JWT)
 
-One common method of cross-origin token redemption is to use the JWT standard. JWTs are a compact, URL-safe means of representing claims to be transferred between two parties. They consist of three parts:
+One common method of cross-origin token redemption is to use the JWT standard.
+JWTs are a compact, URL-safe means of representing claims to be transferred between two parties.
+They consist of three parts:
 
 - `header`: it contains information about the token, including the algorithm used to sign it
 - `payload`: it contains the claims, which are the pieces of information that the token is intended to convey
-- `signature`: is used to verify that the token has not been tampered with.
+- `signature`: is used to verify that the token has not been tampered with
 
-In order to redeem a JWT on a different domain, the receiving domain must first verify the signature using the algorithm specified in the header and the secret key that was used to sign the token. Once the signature is verified, the domain can then read the claims from the payload to determine if the user is authorized to access the requested resources.
+In order to redeem a JWT on a different domain, the receiving domain must first verify the signature using the algorithm specified in the header and the secret key that was used to sign the token.
+Once the signature is verified, the domain can then read the claims from the payload to determine if the user is authorized to access the requested resources.
 
-### **OAuth 2.0**
+## OAuth 2.0
 
-Another method of cross-origin token redemption is to use the OAuth 2.0 standard. OAuth 2.0 is an open standard for authorization that enables a third-party application to obtain limited access to an HTTP service. In this method, when a user is logged in to one website and wants to access resources from another website, the first website will redirect the user to the second website and pass a token. The second website will then validate the token and provide the user with access to the requested resources.
+Another method of cross-origin token redemption is to use the OAuth 2.0 standard.
+OAuth 2.0 is an open standard for authorization that enables a third-party application to obtain limited access to an HTTP service.
+In this method, when a user is logged in to one website and wants to access resources from another website, the first website will redirect the user to the second website and pass a token.
+The second website will then validate the token and provide the user with access to the requested resources.
 
-In summary, cross-origin token redemption is a technique used to ensure the security and authenticity of a token that is issued by one website or domain, but intended for use on a different website or domain. This is achieved by verifying the signature of the token and decrypting it and by using standards like JWT or OAuth 2.0.
+In summary, cross-origin token redemption is a technique used to ensure the security and authenticity of a token that is issued by one website or domain, but intended for use on a different website or domain.
+This is achieved by verifying the signature of the token and decrypting it and by using standards like JWT or OAuth 2.0.
 
 ## FAQ
 
diff --git a/public/md-articles/how-to/what-is-psr-7-and-how-to-use-it.md b/public/md-articles/how-to/what-is-psr-7-and-how-to-use-it.md
index fc5db0af..8128fccb 100644
--- a/public/md-articles/how-to/what-is-psr-7-and-how-to-use-it.md
+++ b/public/md-articles/how-to/what-is-psr-7-and-how-to-use-it.md
@@ -11,36 +11,38 @@ language: "en"
 # What is PSR-7 and how to use it
 
 ## TL;DR
+
 PSR-7 defines a set of common interfaces from the PHP Framework Interop Group for representing HTTP messages and URIs, and any application built on those interfaces is a PSR-7 application.
 This article lists the PSR-7 interfaces as a cheatsheet, then walks through practical examples using Zend Diactoros: adding, appending, reading, and removing HTTP headers, and reading, writing, appending, and prepending content to a PSR-7 message body via its stream interface.
 
-## What is PSR-7 and how to use it
-
-PSR-7 is a set of common interfaces defined by PHP Framework Interop Group. These interfaces are representing HTTP messages, and URIs for use when communicating trough HTTP.
-
+PSR-7 is a set of common interfaces defined by PHP Framework Interop Group.
+These interfaces are representing HTTP messages, and URIs for use when communicating trough HTTP.
 Any web application using this set of interfaces is a PSR-7 application.
-
 More about interfaces and interfaces examples can be found [here](http://php.net/manual/language.oop5.interfaces.php).
 
 ## Interfaces
 
-In this section the Interfaces methods will be listed. The purpose of this list is to help in finding the methods when working with PSR-7. This can be considered as a cheatsheet for PSR-7 interfaces. The interfaces defined in PSR-7 are the following:
+In this section the Interfaces methods will be listed.
+The purpose of this list is to help in finding the methods when working with PSR-7.
+This can be considered as a cheatsheet for PSR-7 interfaces.
+The interfaces defined in PSR-7 are the following:
 
 | Class Name | Description |
-| --- | --- |
-| [PsrHttpMessageMessageInterface](http://www.php-fig.org/psr/psr-7/#psrhttpmessagemessageinterface) | Representation of a HTTP message |
-| [PsrHttpMessageRequestInterface](http://www.php-fig.org/psr/psr-7/#psrhttpmessagerequestinterface) | Representation of an outgoing, client-side request. |
-| [PsrHttpMessageServerRequestInterface](http://www.php-fig.org/psr/psr-7/#psrhttpmessageserverrequestinterface) | Representation of an incoming, server-side HTTP request. |
-| [PsrHttpMessageResponseInterface](http://www.php-fig.org/psr/psr-7/#psrhttpmessageresponseinterface) | Representation of an outgoing, server-side response. |
-| [PsrHttpMessageStreamInterface](http://www.php-fig.org/psr/psr-7/#psrhttpmessagestreaminterface) | Describes a data stream |
-| [PsrHttpMessageUriInterface](http://www.php-fig.org/psr/psr-7/#psrhttpmessageuriinterface) | Value object representing a URI. |
-| [PsrHttpMessageUploadedFileInterface](http://www.php-fig.org/psr/psr-7/#psrhttpmessageuploadedfileinterface) | Value object representing a file uploaded through an HTTP request. |
+|---|---|
+| [`Psr\Http\Message\MessageInterface`](http://www.php-fig.org/psr/psr-7/#psrhttpmessagemessageinterface) | Representation of a HTTP message |
+| [`Psr\Http\Message\RequestInterface`](http://www.php-fig.org/psr/psr-7/#psrhttpmessagerequestinterface) | Representation of an outgoing, client-side request. |
+| [`Psr\Http\Message\ServerRequestInterface`](http://www.php-fig.org/psr/psr-7/#psrhttpmessageserverrequestinterface) | Representation of an incoming, server-side HTTP request. |
+| [`Psr\Http\Message\ResponseInterface`](http://www.php-fig.org/psr/psr-7/#psrhttpmessageresponseinterface) | Representation of an outgoing, server-side response. |
+| [`Psr\Http\Message\StreamInterface`](http://www.php-fig.org/psr/psr-7/#psrhttpmessagestreaminterface) | Describes a data stream |
+| [`Psr\Http\Message\UriInterface`](http://www.php-fig.org/psr/psr-7/#psrhttpmessageuriinterface) | Value object representing a URI. |
+| [`Psr\Http\Message\UploadedFileInterface`](http://www.php-fig.org/psr/psr-7/#psrhttpmessageuploadedfileinterface) | Value object representing a file uploaded through an HTTP request. |
 
 ## Working with PSR-7
 
 The following examples will illustrate how basic operations are done in PSR-7.
-
-Zend Diactoros is an implementation for PSR-7 interfaces. It will be used to illustrate these examples. Installation guide for Zend Diactoros: [Zend Diactoros Documentation – Installation](https://zendframework.github.io/zend-diactoros/install/)
+Zend Diactoros is an implementation for PSR-7 interfaces.
+It will be used to illustrate these examples.
+Installation guide for Zend Diactoros: [Zend Diactoros Documentation – Installation](https://zendframework.github.io/zend-diactoros/install/)
 
 > All other PSR-7 implementations should have the same behaviour.
 
@@ -48,9 +50,9 @@ Alternative [PSR-7 implementations](https://packagist.org/search/?q=psr7%20imple
 
 To use the `Zend Diactoros` classes add this at the beggining of the php file:
 
-```
-use ZendDiactorosServerRequestFactory;
-use ZendDiactorosResponse;
+```php
+use Zend\Diactoros\ServerRequestFactory;
+use Zend\Diactoros\Response;
 // autoloading
 $request = ServerRequestFactory::fromGlobals($_SERVER, $_GET, $_POST, $_COOKIE, $_FILES);
 $response = new Response();
@@ -60,54 +62,47 @@ $response = new Response();
 
 ## Working with HTTP Headers
 
-#### Adding headers to response:
+#### Adding Headers to Response
 
-```
+```php
 $response->withHeader('My-Custom-Header', 'My Custom Message');
 ```
 
-#### Appending values to headers
+#### Appending Values to Headers
 
-```
+```php
 $response->withAddedHeader('My-Custom-Header', 'The second message');
 ```
 
-#### Checking if header exists:
+#### Checking if Header Exists
 
-```
+```php
 $response->hasHeader('My-Custom-Header'); // will return true
 ```
 
 > Note: My-Custom-Header was only added in the Response
 
-#### Getting comma-separated values from a header (also applies to request)
-
-```
-// getting value from request headers
-$request->getHeaderLine('Content-Type'); // will return: "text/html; charset=UTF-8"
-// getting value from response headers
-$response->getHeaderLine('My-Custom-Header'); // will return:  "My Custom Message; The second message"
-```
+#### Getting Comma-Separated Values from a Header (Also Applies to Request)
 
-```
+```php
 // getting value from request headers
 $request->getHeaderLine('Content-Type'); // will return: "text/html; charset=UTF-8"
 // getting value from response headers
 $response->getHeaderLine('My-Custom-Header'); // will return:  "My Custom Message; The second message"
 ```
 
-#### Getting array of value from a header (also applies to request)
+#### Getting Array of Value from a Header (Also Applies to Request)
 
-```
+```php
 // getting value from request headers
 $request->getHeader('Content-Type'); // will return:
 // getting value from response headers
 $response->getHeader('My-Custom-Header'); // will return:
 ```
 
-#### Removing headers from HTTP Messages
+#### Removing Headers from HTTP Messages
 
-```
+```php
 // removing a header from Request, removing deprecated "Content-MD5" header
 $request->withoutHeader('Content-MD5');
 // removing a header from Response
@@ -120,11 +115,11 @@ $response->withoutHeader('Content-Length');
 
 When working with the PSR-7 there are two methods of implementation:
 
-#### 1. Getting the body separately
+#### 1. Getting the Body Separately
 
 > This method makes the body handling easier to understand and is useful when repeatedly calling body methods. (You only call `getBody()` once). Using this method mistakes like `$response->write()` are also prevented.
 
-```
+```php
 $body = $response->getBody();
 // operations on body, eg. read, write, seek
 // ...
@@ -135,21 +130,21 @@ $response->withBody($body);
 // the $body variable has the same value as the one in $request, only the reference is passed
 ```
 
-#### 2. Working directly on response
+#### 2. Working Directly on Response
 
 > This method is useful when only performing few operations as the `$request->getBody()` statement fragment is required
 
-```
+```php
 $response->getBody()->write('hello');
 ```
 
-## Getting the body contents
+## Getting the Body Contents
 
 The following snippet gets the contents of a stream contents.
 
-> Note: Streams must be rewinded, if content was written into streams, it will be ignored when calling `getContents()` because the stream pointer is set to the last character, which is `\0` – meaning end of stream.
+> Note: Streams must be rewinded, if content was written into streams, it will be ignored when calling `getContents()` because the stream pointer is set to the last character, which is end of stream.
 
-```
+```php
 $body = $response->getBody();
 $body->rewind(); // or $body->seek(0);
 $bodyText = $body->getContends();
@@ -157,19 +152,21 @@ $bodyText = $body->getContends();
 
 > Note: If `$body->seek(1)` is called before `$body->getContents()`, the first character will be ommited as the starting pointer is set to `1`, not `0`. This is why using `$body->rewind()` is recommended.
 
-## Append to body
+## Append to Body
 
-```
+```php
 $response->getBody()->write('Hello'); // writing directly
 $body = $request->getBody(); // which is a `StreamInterface`
 $body->write('xxxxx');
 ```
 
-## Prepend to body
+## Prepend to Body
 
-Prepending is different when it comes to streams. The content must be copied before writing the content to be prepended. The following example will explain the behaviour of streams.
+Prepending is different when it comes to streams.
+The content must be copied before writing the content to be prepended.
+The following example will explain the behaviour of streams.
 
-```
+```php
 // assuming our response is initially empty
 $body = $repsonse->getBody();
 // writing the string "abcd"
@@ -180,9 +177,9 @@ $body->seek(0);
 $body->write('ef'); // at this point the stream contains "efcd"
 ```
 
-#### Prepending by rewriting separately
+#### Prepending by Rewriting Separately
 
-```
+```php
 // assuming our response body stream only contains: "abcd"
 $body = $response->getBody();
 $body->rewind();
@@ -195,17 +192,17 @@ $body->write($contents); // stream contains "efabcd"
 
 > Note: `getContents()` seeks the stream while reading it, therefore if the second `rewind()` method call was not present the stream would have resulted in `abcdefabcd` because the `write()` method appends to stream if not preceeded by `rewind()` or `seek(0)`.
 
-#### Prepending by using contents as a string
+#### Prepending by Using Contents as a String
 
-```
+```php
 $body = $response->getBody();
 $body->rewind(); // or $body->seek(0);
 $bodyText = $body->getContends();
 ```
 
-More information can be found in the PSR-7 article in[Dotkernel3 documentation portal](https://www.php-fig.org/psr/psr-7/).
+More information can be found in the [PSR-7 article](https://www.php-fig.org/psr/psr-7/) in Dotkernel3 documentation portal.
 
-Sources: [PSR-7: HTTP messages](http://www.php-fig.org/psr/psr-7/) [zend-diactoros](https://zendframework.github.io/zend-diactoros/)
+Sources: [PSR-7: HTTP messages](http://www.php-fig.org/psr/psr-7/), [zend-diactoros](https://zendframework.github.io/zend-diactoros/)
 
 ## FAQ
 
@@ -219,7 +216,7 @@ A: PSR-7 defines MessageInterface (representation of an HTTP message), RequestIn
 A: Zend Diactoros is used as the PSR-7 implementation for the examples, though the article notes that all other PSR-7 implementations should have the same behaviour.
 
 **Q: How do you add or check headers on a response?**
-A: Use $response->withHeader('My-Custom-Header', 'My Custom Message') to add a header, $response->withAddedHeader(...) to append another value to it, and $response->hasHeader('My-Custom-Header') to check whether it exists.
+A: Use `$response->withHeader('My-Custom-Header', 'My Custom Message')` to add a header, `$response->withAddedHeader(...)` to append another value to it, and `$response->hasHeader('My-Custom-Header')` to check whether it exists.
 
 **Q: Why must a stream be rewound before reading its contents?**
-A: If content was written into a stream, calling getContents() without first calling $body->rewind() (or $body->seek(0)) will return nothing, because the stream pointer is left at the end of the stream after writing.
+A: If content was written into a stream, calling `getContents()` without first calling `$body->rewind()` (or `$body->seek(0)`) will return nothing, because the stream pointer is left at the end of the stream after writing.
diff --git a/public/md-articles/javascript/codelobster-php-edition-free-php-html-css-javascript-editor-ide.md b/public/md-articles/javascript/codelobster-php-edition-free-php-html-css-javascript-editor-ide.md
index 7066d1e8..58fd7825 100644
--- a/public/md-articles/javascript/codelobster-php-edition-free-php-html-css-javascript-editor-ide.md
+++ b/public/md-articles/javascript/codelobster-php-edition-free-php-html-css-javascript-editor-ide.md
@@ -11,44 +11,44 @@ language: "en"
 # Codelobster PHP Edition - Free PHP, HTML, CSS, JavaScript editor (IDE)
 
 ## TL;DR
+
 Codelobster PHP Edition is a free, lightweight IDE that highlights and autocompletes mixed PHP, HTML, CSS, and JavaScript code, including HTML5 and CSS3.
 It also bundles an HTML/CSS inspector, a PHP debugger, an SQL manager, FTP support, and a portable mode that needs no installation.
 On top of that, it ships plugins for popular CMS platforms and PHP frameworks such as Drupal, Joomla, CakePHP, CodeIgniter, Symfony, Yii, WordPress, and Smarty.
 
-## Free PHP, HTML, CSS, JavaScript editor (IDE) - Codelobster PHP Edition
+## Free PHP, HTML, CSS, JavaScript Editor (IDE) - Codelobster PHP Edition
 
 ![Free PHP, HTML, CSS, JavaScript editor (IDE) - Codelobster PHP Edition](http://www.codelobster.com/images/clphped.gif)
 
-For valuable work on creation of sites you need a good comfortable editor necessarily. There are many requiring paid products for this purpose, but we would like to select free of charge very functional and at the same time of simple in the use editor - **[Codelobster PHP Edition](http://www.codelobster.com/)** .
-
-- Let us consider some important possibilities and advantages of this program:
-
- 
-
-- All **code highlights** depending on a type, the also mixed code is thus supported, so the area of HTML will be highlighted as HTML, PHP as PHP, and Javascript as Javascript in a the same file. Thre is possibility of choice from color schemes, including popular IDEs.
-- Powerful **autocompletion for HTML, PHP, CSS and Javascript**, including HTML5 and CSS3. For PHP the structure of project is fully recognized, and the complete list of methods falls out in the proper places.
-- **HTML/CSS** inspector on the type of Firebug, which allows easily to correlate the selected elements of page with a code and proper style.
-- **Context help** on all supported languages. By pressing F1 key the page with detailed description for current tag, attribute or function will be opened.
-- **PHP debugger**. PHP debugger allows to execute PHP scripts incrementally, watching the values of all variables in every line.
-- **SQL manager** allows to produce all necessary actions with a database - to add, delete, edit a structure and records in tables, to export data, execute SQL queries. Highlighting and autocompletion works for SQL files also.
-- **Support of FTP** allows to work straight with a remote server and to do all necessary changes with files;
-- **The portable option** allows to use editor without the preliminary installation.
+For valuable work on creation of sites you need a good comfortable editor necessarily.
+There are many requiring paid products for this purpose, but we would like to select free of charge very functional and at the same time of simple in the use editor - [Codelobster PHP Edition](http://www.codelobster.com/).
+
+Let us consider some important possibilities and advantages of this program:
+
+- All code highlights depending on a type, the also mixed code is thus supported, so the area of HTML will be highlighted as HTML, PHP as PHP, and Javascript as Javascript in a the same file.
+Thre is possibility of choice from color schemes, including popular IDEs.
+- Powerful autocompletion for HTML, PHP, CSS and Javascript, including HTML5 and CSS3.
+For PHP the structure of project is fully recognized, and the complete list of methods falls out in the proper places.
+- HTML/CSS inspector on the type of Firebug, which allows easily to correlate the selected elements of page with a code and proper style.
+- Context help on all supported languages.
+By pressing F1 key the page with detailed description for current tag, attribute or function will be opened.
+- PHP debugger. PHP debugger allows to execute PHP scripts incrementally, watching the values of all variables in every line.
+- SQL manager allows to produce all necessary actions with a database - to add, delete, edit a structure and records in tables, to export data, execute SQL queries.
+Highlighting and autocompletion works for SQL files also.
+- Support of FTP allows to work straight with a remote server and to do all necessary changes with files.
+- The portable option allows to use editor without the preliminary installation.
 - Other useful utilities: pair highlighting, possibility of blocks selection, collapsing, tooltips, navigation on descriptions of functions and included files at withholding of the key of CTRL, viewing of structure of files and project, preview in a browser, book-marks, and all other standard possibilities for work with a code.
 
-### Also there are special plugins for work with:
-
-- CMS: **Drupal, Joomla**
-- PHP frameworks: **CakePHP, CodeIgniter, Symfony, Yii**
-- JavaScript libraly: **JQuery**
-- **WordPress** blogging engine
-- **Smarty** template engine
+### Also There Are Special Plugins for Work With
 
- 
+- CMS: Drupal, Joomla
+- PHP frameworks: CakePHP, CodeIgniter, Symfony, Yii
+- JavaScript libraly: JQuery
+- WordPress blogging engine
+- Smarty template engine
 
 [http://www.codelobster.com](http://www.codelobster.com)
 
- 
-
 ## FAQ
 
 **Q: What kind of code highlighting does Codelobster PHP Edition support?**
diff --git a/public/md-articles/javascript/intro-to-jquery.md b/public/md-articles/javascript/intro-to-jquery.md
index 75fdbb3b..da48e4bc 100644
--- a/public/md-articles/javascript/intro-to-jquery.md
+++ b/public/md-articles/javascript/intro-to-jquery.md
@@ -11,26 +11,26 @@ language: "en"
 # Intro to jQuery
 
 ## TL;DR
+
 Starting with Dotkernel's 1.5 release, the framework switched from Dojo to jQuery, and this post is a quick primer on jQuery basics.
 It covers the jQuery (`$`) object and CSS-style selectors, chaining methods to manipulate matched elements, binding events like click, and making Ajax calls with `$.get()` and `$.getJSON()`.
 
 Starting with the 1.5 release, Dotkernel will make the switch from Dojo to jQuery.
-
 On jQuery's website, there's an excellent "[Getting started with jQuery tutorial](http://docs.jquery.com/Tutorials:Getting_Started_with_jQuery)", as well as a extensive [documentation](http://api.jquery.com/) for the framework, so I'll just go over a few basic concepts and common examples.
 
-## The jQuery object
-
-**jQuery** is the global object that contains all of jQuery's functionality. You will probably want to use **$** instead which is a synonim of the same object, only faster to type.
+## The jQuery Object
 
-It contains a few useful methods such as [jQuery.map](http://api.jquery.com/jQuery.map/), but it's mostly used with a selector parameter to retrieve a set of matched elements.
+jQuery is the global object that contains all of jQuery's functionality.
+You will probably want to use $ instead which is a synonim of the same object, only faster to type.
+It contains a few useful methods such as [jQuery.map](http://api.jquery.com/jQuery.map/), but it's mostly used with a selector parameter to retrieve a set of matched elements.
 
 ## Selectors
 
 jQuery supports the same selectors as CSS (note: all selectors will work even in browsers that don't actually have CSS support for them)
 
-### Examples:
+### Examples
 
-```
+```javascript
 // the element that matches an id
 $("#someId");
 // all elements with a certain class
@@ -41,27 +41,28 @@ $("table#monthlyStats tbody tr:nth-child(odd)")
 
 The results of these expressions is a jQuery object that contains one, more, or no matched elements.
 
-## Manipulating matched elements
+## Manipulating Matched Elements
 
 There are a number of functions that can be applied to a jQuery object, for example:
 
-```
+```javascript
 $("input#username").addClass("error")
 ```
 
-Since most of these functions will also return the same jQuery object, they can be chained. For example, the following expression will set the text of the *#errors* element and fade it in:
+Since most of these functions will also return the same jQuery object, they can be chained.
+For example, the following expression will set the text of the #errors element and fade it in:
 
-```
+```javascript
 $("#errors").text("The was an eror").fadeIn()
 ```
 
 ## Events
 
 Adding events in Javascript instead of using "onclick" attributes in HTML means that the markup is much cleaner, and you get better support for more events in all browsers.
+In the following example, a click event is attached to an element.
+The function that will be called when the event is fired (callback) is passed as an argument to the click function
 
-In the following example, a click event is attached to an element. The function that will be called when the event is fired (callback) is passed as an argument to the *click* function
-
-```
+```javascript
 $("#helpButton").click(function(){
     $("#helpMessage").show()
 });
@@ -71,17 +72,17 @@ $("#helpButton").click(function(){
 
 jQuery has [many ajax helper functions](http://api.jquery.com/category/ajax/), here is a simple example that will replace the contents of an element with data loaded from the server:
 
-```
+```javascript
 $.get("get-news.php", function(result){
    $("#news").html(result)
 })
 ```
 
-## Putting it all together
+## Putting It All Together
 
 The following snippet can be used on a registration form to check whether the username already exists, before the form is submitted.
 
-```
+```javascript
 $(document).ready(
   $("input#username").blur(function(){
     $.getJSON(
@@ -109,10 +110,10 @@ A: Starting with the 1.5 release, Dotkernel makes the switch from Dojo to jQuery
 A: jQuery is the global object that contains all of jQuery's functionality. $ is a synonym for the same object that's faster to type, and is mostly used with a selector parameter to retrieve a set of matched elements.
 
 **Q: What selectors does jQuery support?**
-A: jQuery supports the same selectors as CSS, and these selectors work even in browsers that don't natively support them, for example $("#someId"), $(".someClass"), or $("table#monthlyStats tbody tr:nth-child(odd)").
+A: jQuery supports the same selectors as CSS, and these selectors work even in browsers that don't natively support them, for example `$("#someId")`, `$(".someClass")`, or `$("table#monthlyStats tbody tr:nth-child(odd)")`.
 
 **Q: How do you attach a click event to an element?**
-A: Pass a callback function to the click function on a jQuery selection, for example: $("#helpButton").click(function(){ $("#helpMessage").show() });. This keeps markup cleaner than using "onclick" attributes in HTML.
+A: Pass a callback function to the `click` function on a jQuery selection, for example: `$("#helpButton").click(function(){ $("#helpMessage").show() });`. This keeps markup cleaner than using "onclick" attributes in HTML.
 
 **Q: How does jQuery handle Ajax requests?**
-A: jQuery provides ajax helper functions such as $.get() and $.getJSON(), for example loading data from the server and replacing an element's contents with $.get("get-news.php", function(result){ $("#news").html(result) }).
+A: jQuery provides ajax helper functions such as `$.get()` and `$.getJSON()`, for example loading data from the server and replacing an element's contents with `$.get("get-news.php", function(result){ $("#news").html(result) })`.
diff --git a/public/md-articles/javascript/javascript-email-validator.md b/public/md-articles/javascript/javascript-email-validator.md
index ea1274d0..eb6a8d78 100644
--- a/public/md-articles/javascript/javascript-email-validator.md
+++ b/public/md-articles/javascript/javascript-email-validator.md
@@ -10,15 +10,17 @@ language: "en"
 
 # Javascript: Email Validator
 
-**Problem:** email should allow +/- characters in user, - in domain. dash (-) should be allowed anywhere in an email address or domain. plus (+) is allowed in the username (many people use this for categorization, especially at gmail)
+## Problem
 
-**Solution :**
+Email validation should allow the dash (-) character anywhere in an email address or domain, and the plus (+) character in the username (many people use it for categorization, especially on Gmail).
 
-```
+## Solution
+
+```javascript
 var regex = new RegExp("^+(\.+)*@+(\.+)*\.({2,})$","i");
 ```
 
-This will validated also emails like: username1+username2@gmail-domain.co.uk
+This will also validate emails like `username1+username2@gmail-domain.co.uk`.
 
 ## FAQ
 
diff --git a/public/md-articles/licensing/mit-versus-lgpl-in-practice-dotkernel-case.md b/public/md-articles/licensing/mit-versus-lgpl-in-practice-dotkernel-case.md
index 6ba2a5d8..f197e9fb 100644
--- a/public/md-articles/licensing/mit-versus-lgpl-in-practice-dotkernel-case.md
+++ b/public/md-articles/licensing/mit-versus-lgpl-in-practice-dotkernel-case.md
@@ -11,44 +11,61 @@ language: "en"
 # MIT versus LGPL in practice: Dotkernel case
 
 ## TL;DR
+
 Dotkernel discovered that an upstream dependency, matomo/device-detector, was licensed under LGPL v3 - a more restrictive license than the MIT license Dotkernel uses for its own projects.
 Because the more restrictive license would have to apply to the whole application, Dotkernel implemented a workaround: it stopped bundling that dependency by default and documented the licensing implications.
 
-After a recent analysis, we discovered that **one of the upstream packages** we use is **licensed under [LGPL v3](https://www.gnu.org/licenses/lgpl-3.0.en.html)**. Even though we at **Dotkernel** use the **[MIT](https://opensource.org/license/mit)** license for our open source projects, the more restrictive license must be applied to the whole application. We implemented a workaround detailed below.
-
 ## Detailing the problem
 
-The package in question is [**matomo/device-detector**](https://github.com/matomo-org/device-detector) which requires the developers to **share their derivative code publicly**. This goes against our contractual obligations to the client to keep their custom code business and enterprise friendly. The conflict that results in this scenario may cause **legal issues** in the future.
+The package in question, [matomo/device-detector](https://github.com/matomo-org/device-detector), requires developers to share their derivative code publicly (LGPL v3).
+This conflicted with Dotkernel's contractual obligations to keep client code business and enterprise friendly, and risked legal issues.
 
 ## The solution
 
-Some companies explicitly steer clear of scenarios of this nature and Dotkernel has decided to do the same. Our **solution** for Dotkernel applications and libraries is to **discard the use of 3rd party packages with LGPL v3**. In this particular case we used the **matomo/device-detector** package in our [**dotkernel/dot-user-agent-sniffer**](https://github.com/dotkernel/dot-user-agent-sniffer) package for the purpose of identifying the user agent and using the results in internal reports.
+Dotkernel decided to discard the use of third-party packages licensed under LGPL v3.
+The matomo/device-detector package had been used in [dotkernel/dot-user-agent-sniffer](https://github.com/dotkernel/dot-user-agent-sniffer) to identify the user agent and use the results in internal reports.
 
-ALL of **[Dotkernel's](https://github.com/dotkernel)** packages are licensed under **MIT** which **has no restrictions** regarding the **source code**, other than keeping the license and copyright notice in a file within each package. Other non-restrictive licenses include Apache-2.0, BSD-2-Clause, BSD-3-Clause, ISC, MPL-2.0 and OSL-3.0. Some of them are used by the dependencies in Dotkernel’s packages instead of MIT, but are still deemed acceptable.
+All of [Dotkernel's](https://github.com/dotkernel) packages are licensed under MIT, which has no restrictions on the source code other than keeping the license and copyright notice in a file within each package.
+Other non-restrictive licenses deemed acceptable (used by some dependencies instead of MIT) include Apache-2.0, BSD-2-Clause, BSD-3-Clause, ISC, MPL-2.0 and OSL-3.0.
 
 ## The resolution
 
-The **dotkernel/dot-user-agent-sniffer** package **must follow the LGPL v3 license**, beginning with version 3.4.0. Our [admin application](https://github.com/dotkernel/admin) will not use the features from matomo/device-detector, but will contain instructions on how to add the package, if other developers intend to use it.
+Starting with version 3.4.0, the dotkernel/dot-user-agent-sniffer package must follow the LGPL v3 license.
+The [admin application](https://github.com/dotkernel/admin) will not use the features from matomo/device-detector, but will contain instructions on how to add the package for developers who intend to use it.
 
 ## Important note
 
-**Warning: Any application using dotkernel/dot-user-agent-sniffer with a version lower than 3.4.0 is still a legal liability**. We at Dotkernel will not abandon the issue as is, but are looking into a solution to bring back the device detector functionality in the future under a less restrictive license. For now we will not include dotkernel/dot-user-agent-sniffer in any of our applications by default.
-
-Rob Allen has created an automation to check the licenses of installed packages. You can follow his article [here](https://akrabat.com/check-licenses-of-composer-dependencies/).
+Any application using dotkernel/dot-user-agent-sniffer with a version lower than 3.4.0 is still a legal liability.
+Dotkernel will not abandon the issue, and is looking into a solution to bring back the device detector functionality in the future under a less restrictive license.
+For now, dotkernel/dot-user-agent-sniffer is not included in any Dotkernel application by default.
 
 ## FAQ
 
 **Q: Why did Dotkernel need a workaround for this package?**
-A: An analysis found that an upstream package, matomo/device-detector, was licensed under LGPL v3, which requires developers to share their derivative code publicly. Since Dotkernel's own projects use the MIT license, and the more restrictive license would have to apply to the whole application, this conflicted with contractual obligations to keep client code business and enterprise friendly.
+A: An analysis found that matomo/device-detector was licensed under LGPL v3, which requires sharing derivative code publicly.
+Since Dotkernel projects use MIT, the more restrictive license would have to apply to the whole application, conflicting with contractual obligations to keep client code business friendly.
 
 **Q: Where was the LGPL v3 package being used?**
-A: The matomo/device-detector package was used in Dotkernel's dot-user-agent-sniffer package to identify the user agent and use the results in internal reports.
+A: In Dotkernel's dot-user-agent-sniffer package, to identify the user agent and use the results in internal reports.
 
 **Q: What solution did Dotkernel adopt?**
-A: Dotkernel decided to discard the use of third-party packages licensed under LGPL v3. All of Dotkernel's own packages are licensed under MIT, which has no restrictions on the source code other than keeping the license and copyright notice in a file within each package. Other non-restrictive licenses considered acceptable include Apache-2.0, BSD-2-Clause, BSD-3-Clause, ISC, MPL-2.0 and OSL-3.0.
+A: Discarding the use of third-party LGPL v3 packages.
+All Dotkernel packages are MIT licensed, and other acceptable non-restrictive licenses include Apache-2.0, BSD-2-Clause, BSD-3-Clause, ISC, MPL-2.0 and OSL-3.0.
 
 **Q: What changed in dot-user-agent-sniffer as a result?**
-A: Starting with version 3.4.0, the dotkernel/dot-user-agent-sniffer package must follow the LGPL v3 license. The admin application will not use the features from matomo/device-detector, but will contain instructions for developers who intend to add the package themselves.
+A: Starting with version 3.4.0 it must follow LGPL v3.
+The admin application will not use matomo/device-detector's features, but will document how to add it for developers who want it.
 
 **Q: Is it still risky to use an older version of dot-user-agent-sniffer?**
-A: Yes. Any application using dotkernel/dot-user-agent-sniffer with a version lower than 3.4.0 is still a legal liability. Dotkernel states it will not include dotkernel/dot-user-agent-sniffer in any of its applications by default for now, while it looks into bringing back the device detector functionality under a less restrictive license in the future.
+A: Yes - any application using a version lower than 3.4.0 is still a legal liability.
+Dotkernel will not include the package in its applications by default while it looks for a less restrictive replacement.
+
+## Resources
+
+- [LGPL v3 license](https://opensource.org/license/lgpl-3-0)
+- [MIT license](https://opensource.org/license/mit)
+- [matomo/device-detector](https://github.com/matomo-org/device-detector)
+- [dotkernel/dot-user-agent-sniffer](https://github.com/dotkernel/dot-user-agent-sniffer)
+- [Dotkernel GitHub organization](https://github.com/dotkernel)
+- [Dotkernel admin application](https://github.com/dotkernel/admin)
+- [Rob Allen: Check the licenses of your Composer dependencies](https://akrabat.com/check-licenses-of-composer-dependencies/)
diff --git a/public/md-articles/middleware/dotkernel-light-improvements-psr-15-handlers-vite-phpstan.md b/public/md-articles/middleware/dotkernel-light-improvements-psr-15-handlers-vite-phpstan.md
index 29bb1010..440145f6 100644
--- a/public/md-articles/middleware/dotkernel-light-improvements-psr-15-handlers-vite-phpstan.md
+++ b/public/md-articles/middleware/dotkernel-light-improvements-psr-15-handlers-vite-phpstan.md
@@ -11,6 +11,7 @@ language: "en"
 # Dotkernel Light improvements: PSR-15 Handlers, Vite, PHPStan
 
 ## TL;DR
+
 [Dotkernel Light](https://github.com/dotkernel/light) is a PSR-15 compliant application built on Mezzio and Laminas, aimed at simple websites like presentation sites.
 Since its last update, it has moved from controllers to PSR-15 handlers, adopted Vite as its bundler, replaced Psalm with PHPStan, and picked up several smaller improvements.
 
@@ -20,23 +21,40 @@ Dotkernel Light has come a long way since our [last update](https://www.dotkerne
 
 ## Migrating from controllers to handlers
 
-[dotkernel/dot-controller](https://github.com/dotkernel/dot-controller) isn't going away, but we have switched to [PSR-15](https://www.php-fig.org/psr/psr-15/) handlers instead. [PSR-7 HTTP message interfaces](https://www.php-fig.org/psr/psr-7/) defines the request handler as an individual component that processes a request and produces a response. Given that it's used in a middleware architecture, the request can be wildly different (e.g. filtered, augmented) by the time it reaches your custom code. Handlers split the code into more manageable chunks and cleaner file structure. An added benefit is it allows us to figure out an application's functionality easier. We will expand on this aspect further down in the article, in the 'Naming pattern' chapter.
+[dotkernel/dot-controller](https://github.com/dotkernel/dot-controller) isn't going away, but we have switched to [PSR-15](https://www.php-fig.org/psr/psr-15/) handlers instead.
+[PSR-7 HTTP message interfaces](https://www.php-fig.org/psr/psr-7/) defines the request handler as an individual component that processes a request and produces a response.
+Given that it's used in a middleware architecture, the request can be wildly different (e.g. filtered, augmented) by the time it reaches your custom code.
+Handlers split the code into more manageable chunks and cleaner file structure.
+An added benefit is it allows us to figure out an application's functionality easier.
+We will expand on this aspect further down in the article, in the 'Naming pattern' chapter.
 
 ## Implementing PSR-15 compatible handlers
 
-We are striving to implement every feature with the most modern standards and design patterns in mind. The [PHP Framework Interop Group](https://www.php-fig.org/) defines PSR-15 as common interfaces for HTTP server request handlers and HTTP middleware that use HTTP messages as described by PSR-7. The MVC design pattern is considered obsolete by respected members of the PHP community, so we are replacing it with Middleware and HTTP message desing pattern.
+We are striving to implement every feature with the most modern standards and design patterns in mind.
+The [PHP Framework Interop Group](https://www.php-fig.org/) defines PSR-15 as common interfaces for HTTP server request handlers and HTTP middleware that use HTTP messages as described by PSR-7.
+The MVC design pattern is considered obsolete by respected members of the PHP community, so we are replacing it with Middleware and HTTP message design pattern.
 
 ## Adopting a naming pattern for PSR-15 handlers
 
-Now the file names reflect the functionality at a glance. We devised a naming pattern for our PSR-15 handlers that highlights the method, resouce and action for each file to make navigation and onboarding that much easier. We like to keep things tidy, as well as informative.
+Now the file names reflect the functionality at a glance.
+We devised a naming pattern for our PSR-15 handlers that highlights the method, resource and action for each file to make navigation and onboarding that much easier.
+We like to keep things tidy, as well as informative.
 
 ## Implementing Vite
 
-[Vite](https://vite.dev/) replaces [webpack](https://webpack.js.org) as our static modules bundler. It concatenates and compresses `.css` and `.js` files to enable faster downloads. It also preprocesses `.scss` files into `.css`. As far as devs using Light are concerned, Vite was configured to work similarly to webpack. We decided the technical advantages like easier dependency management and execution speed justified the migration to Vite. It's also highly recommended by the PHP community.
+[Vite](https://vite.dev/) replaces [webpack](https://webpack.js.org) as our static modules bundler.
+It concatenates and compresses `.css` and `.js` files to enable faster downloads.
+It also preprocesses `.scss` files into `.css`.
+As far as devs using Light are concerned, Vite was configured to work similarly to webpack.
+We decided the technical advantages like easier dependency management and execution speed justified the migration to Vite.
+It's also highly recommended by the PHP community.
 
 ## Replacing Psalm with PHPStan
 
-Both [Psalm](https://psalm.dev/) and [PHPStan](https://phpstan.org/) are respected and widely-used static analysis tools. Some of the big names in the PHP ecosystem have opted for the same switch, so we decided to follow suit. Ultimately, the functionality is similar to our previous tool, but the growing interest and improved detection quality make PHPStan a great choice for our applications. PHPStan is configured to run at rule level 8 to help prevent bugs and write better code.
+Both [Psalm](https://psalm.dev/) and [PHPStan](https://phpstan.org/) are respected and widely-used static analysis tools.
+Some of the big names in the PHP ecosystem have opted for the same switch, so we decided to follow suit.
+Ultimately, the functionality is similar to our previous tool, but the growing interest and improved detection quality make PHPStan a great choice for our applications.
+PHPStan is configured to run at rule level 8 to help prevent bugs and write better code.
 
 ## Other updates
 
@@ -50,20 +68,6 @@ Some of the smaller updates involve:
 - Implementing a more reliable and efficient post install script to help get you up and running that much faster.
 - Removing [dotkernel/dot-twigrenderer](https://github.com/dotkernel/dot-twigrenderer) in favor of a direct implementation of [mezzio/mezzio-twigrenderer](https://github.com/mezzio/mezzio-twigrenderer).
 
-## Additional resources
-
-[Dotkernel Light Git](https://github.com/dotkernel/light)
-
-[Dotkernel Light demo](https://light.dotkernel.net/)
-
-[Dotkernel Light documentation](https://docs.dotkernel.org/light-documentation/)
-
-[PHP Framework Interop Group](https://www.php-fig.org/)
-
-[PSR-15: HTTP Server Request Handlers](https://www.php-fig.org/psr/psr-15/)
-
-[Static Analysis – Replacing Psalm with PHPStan](https://www.dotkernel.com/php-development/static-analysis-replacing-psalm-with-phpstan/)
-
 ## FAQ
 
 **Q: Why did Dotkernel Light switch from controllers to handlers?**
@@ -80,3 +84,12 @@ A: Both Psalm and PHPStan are respected, widely-used static analysis tools with
 
 **Q: What other smaller updates were made to Dotkernel Light?**
 A: Other updates include adding support for PHP 8.4, enabling PHPStan and Qodana to run for PHP 8.4, cleaning up the error configuration file, updating laminas/laminas-coding-standard to its latest major version, updating composer.json dependencies and removing obsolete items, implementing a more reliable and efficient post-install script, and removing dotkernel/dot-twigrenderer in favor of a direct implementation of mezzio/mezzio-twigrenderer.
+
+## Resources
+
+- [Dotkernel Light Git](https://github.com/dotkernel/light)
+- [Dotkernel Light demo](https://light.dotkernel.net/)
+- [Dotkernel Light documentation](https://docs.dotkernel.org/light-documentation/)
+- [PHP Framework Interop Group](https://www.php-fig.org/)
+- [PSR-15: HTTP Server Request Handlers](https://www.php-fig.org/psr/psr-15/)
+- [Static Analysis – Replacing Psalm with PHPStan](https://www.dotkernel.com/php-development/static-analysis-replacing-psalm-with-phpstan/)
diff --git a/public/md-articles/middleware/handling-dynamic-routing-using-fastroute-in-dotkernel.md b/public/md-articles/middleware/handling-dynamic-routing-using-fastroute-in-dotkernel.md
index 248c227e..f4df2577 100644
--- a/public/md-articles/middleware/handling-dynamic-routing-using-fastroute-in-dotkernel.md
+++ b/public/md-articles/middleware/handling-dynamic-routing-using-fastroute-in-dotkernel.md
@@ -11,12 +11,17 @@ language: "en"
 # Handling dynamic routing using FastRoute in Dotkernel
 
 ## TL;DR
+
 This article, the first in a series about switching from controllers to PSR-15 compliant handlers, explains how Dotkernel replaced its static, hard-coded route declarations with a centralized, dynamic configuration in `local.php`.
 The change is aimed at static pages only - any method other than GET (post, put, delete) returns a 405 status code.
 
-The goal of this update is to replace the static way of creating routes with a more dynamic implementation. The result is a cleaner approach that is easier to set up and review at a glance.
+The goal of this update is to replace the static way of creating routes with a more dynamic implementation.
+The result is a cleaner approach that is easier to set up and review at a glance.
 
-`RoutesDelegator.php` is used to configure the routes in Dotkernel applications. `Routing` allows web applications to respond to user requests by executing the correct code based on URL paths. The dynamic aspect discussed in this article moves the relevant items for each route into the `local.php` file. The RoutesDelegator then reads the route configuration and generates the routes.
+`RoutesDelegator.php` is used to configure the routes in Dotkernel applications.
+`Routing` allows web applications to respond to user requests by executing the correct code based on URL paths.
+The dynamic aspect discussed in this article moves the relevant items for each route into the `local.php` file.
+The RoutesDelegator then reads the route configuration and generates the routes.
 
 > This is the first in a series of articles for switching from controllers to handlers that are PSR-15 compliant. It's aimed at static pages alone, so any other method like `post`, `put` or `delete` will return a `405 status code`.
 
@@ -24,7 +29,7 @@ The goal of this update is to replace the static way of creating routes with a m
 
 In the past, declaring routes had a more static, hard-coded approach. All our modules have a `RoutesDelegator.php` file in the `src` folder for each module. Each route would have an entry like the one below:
 
-```
+```php
 $app->get('/page[/{action}]', [GetPageViewHandler::class], 'page');
 ```
 
@@ -51,9 +56,10 @@ These items can be grouped into modules, meaning you have to dig into multiple R
 
 ## The new approach
 
-The update centralizes the route configuration in the `config/autoload/local.php` file. Here is how the routing looks out of the box:
+The update centralizes the route configuration in the `config/autoload/local.php` file.
+Here is how the routing looks out of the box:
 
-```
+```php
 'routes'      => [
     'page' => [
         'about'      => 'about',
@@ -70,9 +76,10 @@ Let's list the components under the `routes` array:
 - The key `about` is used to build the page's path.
 - The value `about` is the template file.
 
-In this setup, the `RoutesDelegator` file doesn't need to be touched most of the time. This is how it generates the routes for each page:
+In this setup, the `RoutesDelegator` file doesn't need to be touched most of the time.
+This is how it generates the routes for each page:
 
-```
+```php
 $routes = $container->get('config')['routes'] ?? [];
 foreach ($routes as $prefix => $moduleRoutes) {
     foreach ($moduleRoutes as $routeUri => $templateName) {
@@ -85,27 +92,18 @@ foreach ($routes as $prefix => $moduleRoutes) {
 }
 ```
 
-Each item under `routes` array for each module will have its own entry. The result is you have a `get` for the `about` page and another for the `who-we-are` page.
+Each item under `routes` array for each module will have its own entry.
+The result is you have a `get` for the `about` page and another for the `who-we-are` page.
 
 ## Advanced configuration
 
-You have the same versatility as before for route configuration. Below we explore some scenarios that showcase the control you still have over the routing.
-
-The template file is taken from the path, but you can still change that in the `handler` based on your requirements. Replace `$template = $request->getAttribute(RouteResult::class)->getMatchedRouteName();` with a template of your choosing, like `$template = 'my-template';`
-
-Say you want to change the url from `/page/about`, to `/about` for SEO purposes. All you have to do is remove the `$moduleName` parameter from `sprintf('/%s/%s', $moduleName, $routeUri),` making it `sprintf('/%s', $routeUri),`. Take care not to break other routes, though!
-
-If you need to change the url parameter, you can do that in the `local.php` file. Edit `'about' => 'about',` into `'about-us' => 'about',`. This changes the original url to `/page/about-us`, but uses the same `about` template as before.
+You have the same versatility as before for route configuration.
+Below we explore some scenarios that showcase the control you still have over the routing.
 
-Do you need a dynamic parameter? Edit the route entry from `'about' => 'about',` to `'about/{id}' => 'about',`. This expands the matched url to support something like `/page/about/us`, `/page/about/company`, `/page/about/123` which will allow you to customize each url with different content in the handler. All you need is to use `$request->getAttribute('id')` to tell what page you are on.
-
-## Additional resources
-
-[Dotkernel Light](https://github.com/dotkernel/light)
-
-[Dotkernel Light Routing How to](https://docs.dotkernel.org/light-documentation/v1/how-tos/routing/)
-
-[FastRoute](https://github.com/nikic/FastRoute)
+1. **Change the template**: the template file is taken from the path, but you can still change that in the `handler` based on your requirements. Replace `$template = $request->getAttribute(RouteResult::class)->getMatchedRouteName();` with a template of your choosing, like `$template = 'my-template';`
+2. **Change the URL for SEO**: say you want to change the url from `/page/about`, to `/about` for SEO purposes. All you have to do is remove the `$moduleName` parameter from `sprintf('/%s/%s', $moduleName, $routeUri),` making it `sprintf('/%s', $routeUri),`. Take care not to break other routes, though!
+3. **Change the URL segment**: if you need to change the url parameter, you can do that in the `local.php` file. Edit `'about' => 'about',` into `'about-us' => 'about',`. This changes the original url to `/page/about-us`, but uses the same `about` template as before.
+4. **Add a dynamic parameter**: do you need a dynamic parameter? Edit the route entry from `'about' => 'about',` to `'about/{id}' => 'about',`. This expands the matched url to support something like `/page/about/us`, `/page/about/company`, `/page/about/123` which will allow you to customize each url with different content in the handler. All you need is to use `$request->getAttribute('id')` to tell what page you are on.
 
 ## FAQ
 
@@ -126,3 +124,9 @@ A: Yes. You can change the template used by editing the handler's template attri
 
 **Q: Does this update support methods other than GET?**
 A: No - this is the first in a series of articles for switching from controllers to PSR-15 compliant handlers, and it is aimed at static pages alone, so any other method like post, put or delete will return a 405 status code.
+
+## Resources
+
+- [Dotkernel Light](https://github.com/dotkernel/light)
+- [Dotkernel Light Routing How-to](https://docs.dotkernel.org/light-documentation/v1/how-tos/routing/)
+- [FastRoute](https://github.com/nikic/FastRoute)
diff --git a/public/md-articles/middleware/replacing-controllers-with-psr-15-compliant-handlers-in-dotkernel-light.md b/public/md-articles/middleware/replacing-controllers-with-psr-15-compliant-handlers-in-dotkernel-light.md
index e0e2e051..c436c0d5 100644
--- a/public/md-articles/middleware/replacing-controllers-with-psr-15-compliant-handlers-in-dotkernel-light.md
+++ b/public/md-articles/middleware/replacing-controllers-with-psr-15-compliant-handlers-in-dotkernel-light.md
@@ -11,54 +11,71 @@ language: "en"
 # Replacing controllers with PSR-15 compliant handlers in Dotkernel Light
 
 ## TL;DR
+
 The goal of this update is to implement [PSR-15](https://www.php-fig.org/psr/psr-15/) handlers into [Dotkernel Light](https://github.com/dotkernel/light), keeping the application up-to-date with recommended design guidelines, secure, and aligned with standards widely adopted by the PHP community.
 
-The goal of this update is to implement [PSR-15](https://www.php-fig.org/psr/psr-15/) handlers into [Dotkernel Light](https://github.com/dotkernel/light). There are several advantages to using handlers, which we will explore below.
+The goal of this update is to implement [PSR-15](https://www.php-fig.org/psr/psr-15/) handlers into [Dotkernel Light](https://github.com/dotkernel/light).
+There are several advantages to using handlers, which we will explore below.
 
-We strive to keep our applications up-to-date with the recommended design guidelines. This ensures that we keep the applications secure, while also implementing standards widely adopted by the PHP community.
+We strive to keep our applications up-to-date with the recommended design guidelines.
+This ensures that we keep the applications secure, while also implementing standards widely adopted by the PHP community.
 
 ## What makes handlers better than controllers?
 
-It's all fine and good if you have one large controller file with several actions, but handlers split the code into manageable chunks that make your life a lot easier in the long run. This follows the first of the SOLID principles. SOLID stands for:
+It's all fine and good if you have one large controller file with several actions, but handlers split the code into manageable chunks that make your life a lot easier in the long run.
+This follows the first of the SOLID principles.
+SOLID stands for:
 
-> - S - Single-responsibility Principle
-> - O - Open-closed Principle
-> - L - Liskov Substitution Principle
-> - I - Interface Segregation Principle
-> - D - Dependency Inversion Principle
+- S - Single-responsibility Principle
+- O - Open-closed Principle
+- L - Liskov Substitution Principle
+- I - Interface Segregation Principle
+- D - Dependency Inversion Principle
 
-We are focusing on that first `S` in the SOLID acronym. Instead if having multiple actions we would normally include in controllers, with `single-responsibility` the handlers separate each action into its own class. This makes handlers easier to maintain, refactor and test.
+We are focusing on that first `S` in the SOLID acronym.
+Instead if having multiple actions we would normally include in controllers, with `single-responsibility` the handlers separate each action into its own class.
+This makes handlers easier to maintain, refactor and test.
 
-Expanding your application is also helped by handlers. Rather than searching for a place to fit in that new code, simply create a handler to keep thing orderly. Your future self or the programmer that takes over from you will thank you for it.
+Expanding your application is also helped by handlers.
+Rather than searching for a place to fit in that new code, simply create a handler to keep thing orderly.
+Your future self or the programmer that takes over from you will thank you for it.
 
-Refactoring is always easier if you don't have to worry about edge cases that are unexpectedly not supported because of an error on your part. Simpler code means refactoring steps are more obvious.
+Refactoring is always easier if you don't have to worry about edge cases that are unexpectedly not supported because of an error on your part.
+Simpler code means refactoring steps are more obvious.
 
-Writing tests for actions that have multiple branches tends to take a lot of time. Since handlers only deal with a single action, your tests only have to inject or bind mocks for that specific action.
+Writing tests for actions that have multiple branches tends to take a lot of time.
+Since handlers only deal with a single action, your tests only have to inject or bind mocks for that specific action.
 
 ## How to implement the Page handler
 
-When it comes to [Dotkernel Light](https://github.com/dotkernel/light), replacing controllers with handlers means we don't need the `dot-controller` package any more. Go ahead and remove it, along with any `Controllers` you may have.
+When it comes to [Dotkernel Light](https://github.com/dotkernel/light), replacing controllers with handlers means we don't need the `dot-controller` package any more.
+Go ahead and remove it, along with any `Controllers` you may have.
 
-Below we are going to detail how to set up the `GetPageViewHandler`. If you already have Controllers in your application, you will have to repeat the steps below for each controller. Based on your application, you may have to split your actions over multiple Handlers.
+Below we are going to detail how to set up the `GetPageViewHandler`.
+If you already have Controllers in your application, you will have to repeat the steps below for each controller.
+Based on your application, you may have to split your actions over multiple Handlers.
 
-For Dotkernel Light we were able to combine the functionality of most of the old Controller's `actions` under a single Handler, since the actions performed a single task - displaying static content. The only exception is `IndexHandler.php` which we opted to leave separate, but its setup is similar to GetPageViewHandler.php.
+For Dotkernel Light we were able to combine the functionality of most of the old Controller's `actions` under a single Handler, since the actions performed a single task - displaying static content.
+The only exception is `IndexHandler.php` which we opted to leave separate, but its setup is similar to GetPageViewHandler.php.
 
-Handlers use the `ConfigProvider` in each module to map factories under `getDependencies()`. You should already have delegators and aliases, but make sure to add `GetPageViewHandler` under the `factories` key and remove any reference to PageController.
+Handlers use the `ConfigProvider` in each module to map factories under `getDependencies()`.
+You should already have delegators and aliases, but make sure to add `GetPageViewHandler` under the `factories` key and remove any reference to PageController.
 
-```
+```php
 public function getDependencies(): array
 {
-    return ,
-        ],
-        'factories'  => ,
-        'aliases'    => ,
+    return [
+        ...,
+        'factories'  => [ ... ],
+        'aliases'    => [ ... ],
     ];
 }
 ```
 
-`GetPageViewHandlerFactory.php` adds the template as a dependency, making it available in the Handler. We don't need the PageControllerFactory.php file, so go ahead and delete it.
+`GetPageViewHandlerFactory.php` adds the template as a dependency, making it available in the Handler.
+We don't need the PageControllerFactory.php file, so go ahead and delete it.
 
-```
+```php
 <?php
 
 declare(strict_types=1);
@@ -90,9 +107,11 @@ class GetPageViewHandlerFactory
 }
 ```
 
-`GetPageViewHandler.php` determines the template file name from the route name and displays it. No dynamic elements are included, since we are dealing only with static pages right now. If you haven't already, delete PageController.php.
+`GetPageViewHandler.php` determines the template file name from the route name and displays it.
+No dynamic elements are included, since we are dealing only with static pages right now.
+If you haven't already, delete PageController.php.
 
-```
+```php
 <?php
 
 declare(strict_types=1);
@@ -126,16 +145,6 @@ class GetPageViewHandler implements RequestHandlerInterface
 
 And that's it! These are the bare essentials to get yourself started with handlers for a website that displays static pages.
 
-## Additional resources
-
-[PSR-15](https://www.php-fig.org/psr/psr-15/)
-
-[Dotkernel Light](https://github.com/dotkernel/light)
-
-While the [PR for replacing controllers with handlers](https://github.com/dotkernel/light/pull/33) might not be as focused on the task, because it implements a few other bells and whistles, it's worth reviewing since it includes all the coding details.
-
-[Mezzio features](https://docs.mezzio.dev/mezzio/v3/getting-started/features/)
-
 ## FAQ
 
 **Q: What is the goal of replacing controllers with PSR-15 handlers?**
@@ -152,3 +161,10 @@ A: Handlers are registered in each module's ConfigProvider, mapping factories un
 
 **Q: Does every action need its own separate handler?**
 A: Not necessarily. For Dotkernel Light, most of the old Controller's actions were combined under a single Handler since they performed a single task - displaying static content. The exception is IndexHandler.php, which was kept separate but is set up similarly to GetPageViewHandler.php. Depending on your application, you may need to split actions over multiple handlers.
+
+## Resources
+
+- [PSR-15](https://www.php-fig.org/psr/psr-15/)
+- [Dotkernel Light](https://github.com/dotkernel/light)
+- [PR for replacing controllers with handlers](https://github.com/dotkernel/light/pull/33)
+- [Mezzio features](https://docs.mezzio.dev/mezzio/v3/getting-started/features/)
diff --git a/public/md-articles/php-development/almalinux-9-in-wsl2-install-php-apache-mariadb-composer-phpmyadmin.md b/public/md-articles/php-development/almalinux-9-in-wsl2-install-php-apache-mariadb-composer-phpmyadmin.md
index c3b2c724..e29942cd 100644
--- a/public/md-articles/php-development/almalinux-9-in-wsl2-install-php-apache-mariadb-composer-phpmyadmin.md
+++ b/public/md-articles/php-development/almalinux-9-in-wsl2-install-php-apache-mariadb-composer-phpmyadmin.md
@@ -11,14 +11,16 @@ language: "en"
 # AlmaLinux 9 in WSL2 : install PHP, Apache, MariaDB, Composer, PhpMyadmin
 
 ## TL;DR
+
 This guide shows how to install AlmaLinux 9 through Windows Subsystem for Linux (WSL2) and provision it with an Ansible-driven installer script that sets up PHP, Apache, MariaDB, Composer, and phpMyAdmin.
 It covers verifying WSL2 readiness, installing the AlmaLinux 9 distribution from the Microsoft Store, running the two-step Ansible installer (with a required restart in between), and confirming the setup through Apache's homepage, a PHP info page, and phpMyAdmin.
 
 In this article we will demonstrate how we install AlmaLinux 9 using Windows Subsystem for Linux (WSL2).
 
-First, you need to check if your machine is ready for using WSL2. Open Windows Terminal and execute the following command:
+First, you need to check if your machine is ready for using WSL2.
+Open Windows Terminal and execute the following command:
 
-```
+```bash
 wsl -v
 ```
 
@@ -34,11 +36,14 @@ DXCore version: 10.0.26091.1-240325-1447.ge-release
 Windows version: 10.0.22631.3737
 ```
 
-If instead of the above output, you get an error, it means that WSL is not (completely) installed on your machine. In this case, please follow the instructions found in [this guide](https://docs.dotkernel.org/development/v1/setup/installation/), then return to this page and continue with the next step.
+If instead of the above output, you get an error, it means that WSL is not (completely) installed on your machine.
+In this case, please follow the instructions found in [this guide](https://docs.dotkernel.org/development/v1/setup/installation/), then return to this page and continue with the next step.
 
-## Download and install AlmaLinux 9
+## Download and Install AlmaLinux 9
 
-Open Microsoft Store and search for `AlmaLinux`. From the results, select `AlmaLinux 9` and install it. Once installed, clicking on *Open* will open it in Windows Terminal.
+Open Microsoft Store and search for `AlmaLinux`.
+From the results, select `AlmaLinux 9` and install it.
+Once installed, clicking on *Open* will open it in Windows Terminal.
 
 The installer will prompt you for your *username*, your *password* and *password confirmation*.
 
@@ -48,39 +53,40 @@ While still in the AlmaLinux 9 terminal, start executing the following commands.
 
 Install required packages:
 
-```
+```bash
 sudo dnf install epel-release dnf-utils http://rpms.remirepo.net/enterprise/remi-release-9.rpm -y
 ```
 
 Update installed packages:
 
-```
+```bash
 sudo dnf upgrade -y
 ```
 
 Install Ansible:
 
-```
+```bash
 sudo dnf install ansible -y
 ```
 
 Clone our development environment setup package:
 
-```
+```bash
 git clone https://github.com/dotkernel/development.git
 ```
 
 Navigate to the directory with the Ansible recipes:
 
-```
+```bash
 cd ~/development/wsl/
 ```
 
-Using your preferred text editor, open **config.yml** where you must fill in the empty fields. Save and close the file.
+Using your preferred text editor, open **config.yml** where you must fill in the empty fields.
+Save and close the file.
 
 Run Step 1 of the installer script (it will prompt you for the password you entered during the installation process):
 
-```
+```bash
 ansible-playbook -i hosts install.yml --ask-become-pass
 ```
 
@@ -93,13 +99,13 @@ Restart AlmaLinux 9:
 
 Navigate back to the directory with the Ansible recipes:
 
-```
+```bash
 cd ~/development/wsl/
 ```
 
 Run Step 2 of the installer script (once again, it will prompt you for the password you entered during the installation process):
 
-```
+```bash
 ansible-playbook -i hosts install.yml --ask-become-pass
 ```
 
diff --git a/public/md-articles/php-development/aptana-php-installation-in-aptana-2-x.md b/public/md-articles/php-development/aptana-php-installation-in-aptana-2-x.md
index 4481d2a8..ffc076fe 100644
--- a/public/md-articles/php-development/aptana-php-installation-in-aptana-2-x.md
+++ b/public/md-articles/php-development/aptana-php-installation-in-aptana-2-x.md
@@ -11,10 +11,13 @@ language: "en"
 # Aptana PHP installation in Aptana 2.x
 
 ## TL;DR
+
 Aptana discontinued its bundled Aptana PHP plugin in Aptana 2.x in favor of PDT, but PDT is missing major features needed for professional PHP development.
 This article shows how to manually reinstall the Aptana PHP plugin through Aptana's update site, and how to add SVN support via Subclipse if it isn't already installed.
 
-As all [aptana](http://www.aptana.org/) fans know, [Aptana PHP](http://www.aptana.org/php) plugin was discontinued in Aptana 2.x, in favor of PDT. But PDT is a joke, not suitable for professional PHP development, major features are missing. So if you want to continue using Aptana PHP, that's what need to be done:
+As all [aptana](http://www.aptana.org/) fans know, [Aptana PHP](http://www.aptana.org/php) plugin was discontinued in Aptana 2.x, in favor of PDT.
+But PDT is a joke, not suitable for professional PHP development, major features are missing.
+So if you want to continue using Aptana PHP, that's what need to be done:
 
 1. Aptana -> Help -> Install New Software
 2. Add http://update.aptana.com/install/php
diff --git a/public/md-articles/php-development/better-unicode-support-in-mysql-5-5-utf8mb4.md b/public/md-articles/php-development/better-unicode-support-in-mysql-5-5-utf8mb4.md
index 416832d6..1b14f2fa 100644
--- a/public/md-articles/php-development/better-unicode-support-in-mysql-5-5-utf8mb4.md
+++ b/public/md-articles/php-development/better-unicode-support-in-mysql-5-5-utf8mb4.md
@@ -11,37 +11,40 @@ language: "en"
 # Better Unicode Support in MySQL 5.5 UTF8MB4
 
 ## TL;DR
+
 MySQL 5.5 introduced the utf8mb4 character set for fuller Unicode support, and Dotkernel's sample dk.sql file was updated to use it.
 Switching to utf8mb4 means VARCHAR(255) columns can hit MySQL's 767-byte max key length error, so VARCHAR(150) is used instead, and the connection charset must be updated in both the application config and my.cnf.
 
-Beginning with version 5.5 of MySQL , **utf8mb4** character set was introduced, in order to better support **Unicode**. Further reading: [MySQL and Unicode](http://mzsanford.com/blog/mysql-and-unicode/) , also directly related to [PHP](http://www.phptherightway.com/#php_and_utf8)
+Beginning with version 5.5 of MySQL, utf8mb4 character set was introduced, in order to better support Unicode.
+Further reading: [MySQL and Unicode](http://mzsanford.com/blog/mysql-and-unicode/), also directly related to [PHP](http://www.phptherightway.com/#php_and_utf8).
 
-Sample dk.sql file, part of Dotkernel framework, was updated in [revision 793](http://websvn.dotkernel.net/filedetails.php?repname=Dotkernel&path=%2Ftrunk%2Fdot_kernel.sql&rev=793&peg=793)
+Sample dk.sql file, part of Dotkernel framework, was updated in [revision 793](http://websvn.dotkernel.net/filedetails.php?repname=Dotkernel&path=%2Ftrunk%2Fdot_kernel.sql&rev=793&peg=793).
 
-Only one downside , is not possible to use anymore VARCHAR(255), as you will get the error:
+Only one downside, is not possible to use anymore VARCHAR(255), as you will get the error:
 
 ```
 #1071 - Specified key was too long; max key length is 767 bytes
 ```
 
-Explanation [here](http://stackoverflow.com/questions/1814532/1071-specified-key-was-too-long-max-key-length-is-767-bytes) ; so we use instead VARCHAR(150)
+Explanation [here](http://stackoverflow.com/questions/1814532/1071-specified-key-was-too-long-max-key-length-is-767-bytes); so we use instead VARCHAR(150).
 
-Now we should change the connection charset. In config/application.ini file, edit the below line :
+Now we should change the connection charset.
+In config/application.ini file, edit the below line:
 
-```
+```ini
 database.params.charset = utf8mb4
 ```
 
-Other changes that can be made in **my.cnf** file are all related to replacing the string **utf8_*** with **utf8mb4_***
+Other changes that can be made in my.cnf file are all related to replacing the string utf8_* with utf8mb4_*.
 
-```
+```ini
 character_set_server=utf8mb4
 ```
 
-```
+```ini
 collation_server=utf8mb4_general_ci
 ```
 
-```
+```ini
 collation_server=utf8mb4_unicode_ci
 ```
diff --git a/public/md-articles/php-development/database-seeding-doctrine-data-fixtures-vs-phinx.md b/public/md-articles/php-development/database-seeding-doctrine-data-fixtures-vs-phinx.md
index 1932293f..33e164ce 100644
--- a/public/md-articles/php-development/database-seeding-doctrine-data-fixtures-vs-phinx.md
+++ b/public/md-articles/php-development/database-seeding-doctrine-data-fixtures-vs-phinx.md
@@ -11,46 +11,49 @@ language: "en"
 # Database seeding: Doctrine data fixtures vs Phinx
 
 ## TL;DR
+
 Dotkernel 3 previously used cakephp/phinx for seeding the database, but the team wanted more flexibility and switched to doctrine/data-fixtures since Doctrine is already the ORM in use.
 Because doctrine/data-fixtures has no CLI interface, Dotkernel built the dotkernel/dot-data-fixtures package to add one, and this article covers installing it, creating and executing fixtures, and ordering them by explicit order or by declared dependencies.
 
-## Database seeding: Doctrine data fixtures vs Phinx
+## Database Seeding: Doctrine Data Fixtures vs Phinx
 
 Seeding the database means populating the database with initial values, it's commonly used for seeding the user roles and user accounts.
-
 Seeding the database the right way is no easy feat, and we will see why.
 
-Previous versions of **Dotkernel 3** used [cakephp](https://github.com/cakephp)/**[phinx](https://github.com/cakephp/phinx)** for seeding the database. While the package did a great job at populating the database, we wanted more. We wanted more flexibility - so we started to search for alternatives.
+Previous versions of Dotkernel 3 used [cakephp](https://github.com/cakephp)/[phinx](https://github.com/cakephp/phinx) for seeding the database.
+While the package did a great job at populating the database, we wanted more.
+We wanted more flexibility - so we started to search for alternatives.
 
 Because we are using Doctrine as our database abstraction layer, the obvious choice was to give [doctrine/data-fixtures](https://github.com/doctrine/data-fixtures) a shot and use it as our database seeder, instead of phinx - but there's a catch.
 
-## The catch
-
-Using the [doctrine/data-fixtures](https://github.com/doctrine/data-fixtures) package provides a concrete implementation of data fixtures, **without a CLI interface**.
+## The Catch
 
-We need a way to interact with the fixtures, so we created a **package** ([dotkernel/dot-data-fixtures](https://github.com/dotkernel/dot-data-fixtures)) to provide a CLI interface. While there are alternatives that can achieve this out-of-the-box we wanted something slim (in terms of dependencies) and easy to use.
+Using the [doctrine/data-fixtures](https://github.com/doctrine/data-fixtures) package provides a concrete implementation of data fixtures, without a CLI interface.
+We need a way to interact with the fixtures, so we created a package ([dotkernel/dot-data-fixtures](https://github.com/dotkernel/dot-data-fixtures)) to provide a CLI interface.
+While there are alternatives that can achieve this out-of-the-box we wanted something slim (in terms of dependencies) and easy to use.
 
-### NOTE:
+### Note
 
-The package [dotkernel/dot-data-fixture](https://github.com/dotkernel/dot-data-fixtures) does **NOT** depend on other Dotkernel packages. The only dependency is **Doctrine**
+The package [dotkernel/dot-data-fixtures](https://github.com/dotkernel/dot-data-fixtures) does NOT depend on other Dotkernel packages.
+The only dependency is Doctrine.
 
 ## Installation
 
-Run the following command in you project directory:
+Run the following command in your project directory:
 
-```
-$ composer require dotkernel/dot-data-fixtures
+```bash
+composer require dotkernel/dot-data-fixtures
 ```
 
 Register the package's `ConfigProvider.php` in `config/config.php`.
 
-```
+```php
 \Dot\DataFixtures\ConfigProvider::class,
 ```
 
-In `doctrine.global.php` (or your custom doctrine config file) add a new key `fixtures`, in the `doctrine` array, the value should be a valid path to a folder where your fixtures can be found.
+In `doctrine.global.php` (or your custom doctrine config file) add a new key `fixtures`, in the `doctrine` array, the value should be a valid path to a folder where your fixtures can be found.
 
-```
+```php
 return [
     'dependencies' => [ ... ],
     'doctrine' => [
@@ -60,17 +63,15 @@ return [
 ];
 ```
 
-**Make sure the path is valid before proceeding to the next step.**
-
-The fixtures can be found in the `/data/doctrine/fixtures` folder, but you can create a custom folder for them. We choose this location because the migrations live in the `/data/doctrine/migrations` folder.
+Make sure the path is valid before proceeding to the next step.
+The fixtures can be found in the `/data/doctrine/fixtures` folder, but you can create a custom folder for them.
+We choose this location because the migrations live in the `/data/doctrine/migrations` folder.
 
 The last step is to register 2 commands.
-
 We will register the commands to work with the doctrine default CLI but you can register them as normal commands also.
-
 Create a new php file `bin/doctrine` if you don't have it already and paste the below code block.
 
-```
+```php
 <?php
 
 use Doctrine\ORM\Tools\Console\ConsoleRunner;
@@ -78,7 +79,7 @@ use Doctrine\ORM\Tools\Console\EntityManagerProvider\SingleManagerProvider;
 
 require_once 'vendor/autoload.php';
 
-$container = require getcwd() . '/config/container.php' ;
+$container = require getcwd() . '/config/container.php';
 
 $entityManager = $container->get(\Doctrine\ORM\EntityManager::class);
 
@@ -95,7 +96,7 @@ ConsoleRunner::run(
 
 The installation is complete, we can verify it by running the following command in our terminal.
 
-```
+```bash
 php bin/console
 ```
 
@@ -105,38 +106,36 @@ It should print out all the doctrine CLI commands available, including our fixtu
 
 ## Usage
 
-### List all available fixtures, by order of execution:
+### List All Available Fixtures, by Order of Execution
 
-```
+```bash
 php bin/doctrine fixtures:list
 ```
 
 ![](/uploads/article/019f8a80-cc6c-71e3-a52c-9a9b1a204472/Screenshot-2022-08-30-at-19.22.45-1024x147.png)
 
-**By using this command you can check the execution order of your fixtures *before executing them*.**
+By using this command you can check the execution order of your fixtures before executing them.
 
-### Executing fixtures:
+### Executing Fixtures
 
-To execute all fixtures run : `php bin/doctrine fixtures:execute`
+To execute all fixtures run: `php bin/doctrine fixtures:execute`
+To run a specific fixture run: `php bin/doctrine fixtures:execute --class={FixtureClassName}`
+Example:
 
-To run a specific fixture run : `php bin/doctrine fixtures:execute --class={FixtureClassName}`
-
-Example :
-
-```
+```bash
 php bin/console fixtures:execute --class=RoleLoader
 ```
 
-## Creating fixtures
+## Creating Fixtures
 
-When creating fixtures, we need to :
+When creating fixtures, we need to:
 
 - Create the fixture in the configured folder (`/data/doctrine/fixtures`).
 - Implement `Doctrine\Common\DataFixtures\FixtureInterface` interface.
 
-Example :
+Example:
 
-```
+```php
 <?php
 
 namespace Frontend\Fixtures;
@@ -171,24 +170,23 @@ class RoleLoader implements FixtureInterface
 }
 ```
 
-## Ordering fixtures
+## Ordering Fixtures
 
-We can order fixtures using 2 methods :
+We can order fixtures using 2 methods:
 
 1. By Order - you can specify the order of execution, by implementing `OrderedFixtureInterface` interface.
-2. By dependencies - let's you specify dependency fixtures, chaining fixtures and executing them in the right order
-
-**Practical example:**
+2. By dependencies - lets you specify dependency fixtures, chaining fixtures and executing them in the right order.
 
-**Requirements**: Seed the database with a new admin user.
+Practical example:
+Requirements: Seed the database with a new admin user.
 
-We will use the second method to order fixtures and need 2 fixtures to achieve this, one of them will create a new user and the other will create a new admin role. In this case the **order matters, we can't create the admin user without having an admin role**.
+We will use the second method to order fixtures and need 2 fixtures to achieve this, one of them will create a new user and the other will create a new admin role.
+In this case the order matters, we can't create the admin user without having an admin role.
 
 Create new php file in `data/doctrine/fixtures` with the name `RoleLoader.php`.
-
 This fixture will be executed first and create our user roles.
 
-```
+```php
 <?php
 
 namespace Frontend\Fixtures;
@@ -225,7 +223,7 @@ class RoleLoader implements FixtureInterface
 
 The second fixture is `UserLoader.php` and will contain the following code:
 
-```
+```php
 <?php
 
 namespace Frontend\Fixtures;
@@ -275,15 +273,12 @@ class UserLoader implements FixtureInterface, DependentFixtureInterface
 ```
 
 Notice how `UserLoader.php` implements 2 interfaces, `FixtureInterface` and `DependentFixtureInterface`.
-
 The method `getDependencies()` returns an array containing the dependencies (fixtures) that need to be executed prior to the current one.
-
 After running all the fixtures using `php bin/doctrine fixtures:execute` the output should look like this:
 
 ![](/uploads/article/019f8a80-cc6c-71e3-a52c-9a9b1a204472/Screenshot-2022-08-30-at-20.39.19.png)
 
 `RoleLoader` was executed before `UserLoader` because `UserLoader` had `RoleLoader` as a dependency.
 
-**To wrap things up, we implemented a database seeder and saw a practical example of how to use it.**
-
-More details about Fixtures in this blogpost: [https://matthiasnoback.nl/2018/07/about-fixtures/](https://matthiasnoback.nl/2018/07/about-fixtures/) .
+To wrap things up, we implemented a database seeder and saw a practical example of how to use it.
+More details about Fixtures in this blogpost: [https://matthiasnoback.nl/2018/07/about-fixtures/](https://matthiasnoback.nl/2018/07/about-fixtures/).
diff --git a/public/md-articles/php-development/end-of-support-for-php-5-2-x-branch.md b/public/md-articles/php-development/end-of-support-for-php-5-2-x-branch.md
index de24dc73..51819e1f 100644
--- a/public/md-articles/php-development/end-of-support-for-php-5-2-x-branch.md
+++ b/public/md-articles/php-development/end-of-support-for-php-5-2-x-branch.md
@@ -11,22 +11,34 @@ language: "en"
 # End of Support for PHP 5.2.x Branch
 
 ## TL;DR
+
 PHP 5.2.14 was just released, marking the end of active support for the PHP 5.2.x branch.
 PHP 5.3.3 was released at the same time, and projects and servers are encouraged to upgrade to the 5.3.x branch.
 
-[PHP 5.2.14](http://www.php.net/ChangeLog-5.php#5.2.14) was just released . And this is the end of support for 5.2.x branch of PHP .
+## The announcement
+
+PHP 5.2.14 was just released, and this is the end of support for the 5.2.x branch of PHP.
 
-> **NOTE:**This release marks the end of the active support for PHP 5.2. Following this release the PHP 5.2 series will receive no further active bug maintenance. Security fixes for PHP 5.2 might be published on a case by cases basis. All users of PHP 5.2 are encouraged to upgrade to PHP 5.3
+> **NOTE:** This release marks the end of the active support for PHP 5.2.
+> Following this release the PHP 5.2 series will receive no further active bug maintenance.
+> Security fixes for PHP 5.2 might be published on a case by case basis.
+> All users of PHP 5.2 are encouraged to upgrade to PHP 5.3
 
-[PHP 5.3.3](http://www.php.net/ChangeLog-5.php#5.3.3) is just released ,  so is time to upgrade every project  to PHP 5.3.x branch, and also upgrade all servers to 5.3.x
+PHP 5.3.3 was also just released, so it is time to upgrade every project to the PHP 5.3.x branch, and also upgrade all servers to 5.3.x.
 
 ## FAQ
 
 **Q: What does the release of PHP 5.2.14 mean for the 5.2.x branch?**
-A: PHP 5.2.14 marks the end of active support for the PHP 5.2 branch. After this release, PHP 5.2 will receive no further active bug maintenance, though security fixes might still be published on a case-by-case basis.
+A: PHP 5.2.14 marks the end of active support for the PHP 5.2 branch.
+After this release, PHP 5.2 will receive no further active bug maintenance, though security fixes might still be published on a case-by-case basis.
 
 **Q: What should users of PHP 5.2 do?**
 A: All users of PHP 5.2 are encouraged to upgrade to PHP 5.3.
 
 **Q: Which PHP version was just released alongside the end of 5.2.x support?**
 A: PHP 5.3.3 was just released, so it is time to upgrade every project to the PHP 5.3.x branch and also upgrade all servers to 5.3.x.
+
+## Resources
+
+- [PHP 5.2.14 changelog](http://www.php.net/ChangeLog-5.php#5.2.14)
+- [PHP 5.3.3 changelog](http://www.php.net/ChangeLog-5.php#5.3.3)
diff --git a/public/md-articles/php-development/floating-point-arithmetic-why-is-int-0-7-0-1-10-7.md b/public/md-articles/php-development/floating-point-arithmetic-why-is-int-0-7-0-1-10-7.md
index f621bec5..f5da37cc 100644
--- a/public/md-articles/php-development/floating-point-arithmetic-why-is-int-0-7-0-1-10-7.md
+++ b/public/md-articles/php-development/floating-point-arithmetic-why-is-int-0-7-0-1-10-7.md
@@ -11,85 +11,99 @@ language: "en"
 # Floating-Point Arithmetic - Why is (int)((0.7+0.1)*10) = 7 ?
 
 ## TL;DR
+
 This applies to PHP 5.x and PHP 7.
 Floating-point arithmetic doesn't always produce the results you'd expect, especially when casting values to int, because numbers like 0.7 and 0.1 cannot be represented exactly in binary.
 The result is that `(int)((0.7+0.1)*10)` evaluates to 7 instead of the mathematically expected 8.
 
-This article applies to **PHP 5.x** but also to **PHP 7**
-
-While using **floating-point arithmetic** you might have noticed that not all the calculus results are as expected, this can usually be observed when casting values.
+## The problem
 
-So the output for **(0.7 + 0.1) * 10** is: 
-`var_dump((0.7+0.1)*10); # float(8)
-var_dump(intval((0.7+0.1)*10)); # int(7)`
+While using floating-point arithmetic you might have noticed that not all calculation results are as expected - this can usually be observed when casting values.
 
-Now let's try it with 0.6 instead of 0.7 
-`var_dump((0.6+0.1)*10); # float(7)
-var_dump(intval((0.6+0.1)*10)); # int(7)`
+The output for `(0.7 + 0.1) * 10` is:
 
-## How does the CPU understand these numbers?
+```php
+var_dump((0.7+0.1)*10); # float(8)
+var_dump(intval((0.7+0.1)*10)); # int(7)
+```
 
-The CPU makes the calculations binary, the floating point numbers are represented as follows:
+The same thing happens with 0.6 instead of 0.7:
 
-IEEE Short Real: **32 bits**     1 bit for the sign, 8 bits for the exponent, and 23 bits for the mantissa. Also called single precision. IEEE Long  Real: **64 bits**     1 bit for the sign, 11 bits for the exponent, and 52 bits for the mantissa. Also called double precision.
+```php
+var_dump((0.6+0.1)*10); # float(7)
+var_dump(intval((0.6+0.1)*10)); # int(7)
+```
 
-The numbers that can easily be represented binary are: 1/(2^1). 1/(2^2) . 1/(2^3), 1/(2^4) etc. This because they have mantissa equal to 1 (enconded as 0).
+## How does the CPU understand these numbers?
 
-The number values can only be represented exactly if they can be represented by this formula:  **exponent** * **mantissa**
+The CPU makes calculations in binary; floating-point numbers are represented as follows:
 
-The **mantissa** is the number which the exponent is multiplied to. The mantissa value is **1 + 1/rb**, where **rb** is the reverse binary interpretation
+| Format | Size | Sign | Exponent | Mantissa |
+|---|---|---|---|---|
+| IEEE Short Real (single precision) | 32 bits | 1 bit | 8 bits | 23 bits |
+| IEEE Long Real (double precision) | 64 bits | 1 bit | 11 bits | 52 bits |
 
-Let's take the number 3.5 for example.
+Numbers that can easily be represented in binary are 1/(2^1), 1/(2^2), 1/(2^3), 1/(2^4), etc., because they have a mantissa equal to 1 (encoded as 0).
 
-The float numbers are **sign** * **exponent** * **mantissa. ** 3.5 = **1** * **2** * **1.75** .
+A number's value can only be represented exactly if it can be expressed by the formula **exponent * mantissa**.
+The mantissa is the number the exponent is multiplied by, and its value is 1 + 1/rb, where rb is the reverse binary interpretation.
 
-**Mantissa: 1 + 11**000000000000000000000 -> 1/(2^0) + **1**/(2^1) + **1**/(2^2) + **0***(2^3) + ... + **0***(2^23) -> 1 + 0.5 + 0.25 -> 1.75
+For example, take the number 3.5: 3.5 = sign(1) * exponent(2) * mantissa(1.75).
 
-Some numbers cannot be represented exactly (such as  0.99999999)
+Mantissa: 1 + 11000000000000000000000 -> 1/(2^0) + 1/(2^1) + 1/(2^2) + 0*(2^3) + ... + 0*(2^23) -> 1 + 0.5 + 0.25 -> 1.75
 
-To learn more about how IEEE Real numbers are formed follow [this link](http://kipirvine.com/asm/workbook/floating_tut.htm).
+Some numbers cannot be represented exactly (such as 0.99999999).
 
 ## Why does this happen?
 
-Using this [IEEE 754 converter](http://www.h-schmidt.net/FloatConverter/IEEE754.html) we have found out that:
-
-**0.7** is actually represented as **0.699999988079071**
+Using an IEEE 754 converter, it turns out that:
 
-**0.1** is actually represented as **0.10000000149011612**
+- 0.7 is actually represented as 0.699999988079071
+- 0.1 is actually represented as 0.10000000149011612
 
-If we add these two values we will obtain **0.7999999895691871**
+Adding these two values gives 0.7999999895691871.
+Multiplying by 10 gives 7.999999895691871, which when cast to int is 7 - the same way 3.5 is 3 when cast to int.
 
-And if we multiply it by 10 we obtain **7.999999895691871** which if casted to int is **7** the same way **3.5** is **3** if casted to int.
-
-The other example still shows 7 because **0.6** is actually represented as **0.6000000238418579** and  (0.6000000238418579 + 0.10000000149011612)*10 is **7,00000025331974**
-
- 
+The 0.6 example still shows 7 because 0.6 is actually represented as 0.6000000238418579, and (0.6000000238418579 + 0.10000000149011612) * 10 is 7.00000025331974.
 
 ## But still ...
 
-If we use **echo** and **var_dump** or if applying mathematical operations, PHP automatically adjusts the values, but **intval** and casting to **int** work on their bits before the values were adjusted
-
-`var_dump((0.7+0.1)*10); # float(8)
-var_dump(intval( ((0.7+0.1)*10) ) );   # int(7)
-var_dump(intval( ((0.7+0.1)*10)+1 ) ); # int(9)`
+If you use echo and var_dump, or apply mathematical operations, PHP automatically adjusts the values - but intval and casting to int work on the underlying bits before those values were adjusted:
 
-If these values are very important for your project you can get the correct values we by using the [**BCMath PHP Extension**](http://php.net/manual/en/book.bc.php).
+```php
+var_dump((0.7+0.1)*10); # float(8)
+var_dump(intval( ((0.7+0.1)*10) ) );   # int(7)
+var_dump(intval( ((0.7+0.1)*10)+1 ) ); # int(9)
+```
 
-For a more technical & mathematical approach read [this document](http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html).
+If these values are important for your project, you can get correct results by using the BCMath PHP Extension.
 
 ## FAQ
 
-**Q: Why does (int)((0.70.1)*10) return 7 instead of 8?**
-A: Because 0.7 is actually represented internally as 0.699999988079071 and 0.1 as 0.10000000149011612. Adding them gives 0.7999999895691871, and multiplying by 10 gives 7.999999895691871, which truncates to 7 when cast to int.
+**Q: Why does (int)((0.7+0.1)*10) return 7 instead of 8?**
+A: Because 0.7 is actually represented internally as 0.699999988079071 and 0.1 as 0.10000000149011612.
+Adding them gives 0.7999999895691871, and multiplying by 10 gives 7.999999895691871, which truncates to 7 when cast to int.
 
 **Q: Does the same rounding issue happen with 0.6 instead of 0.7?**
-A: Yes. 0.6 is represented as 0.6000000238418579, and (0.6000000238418579 + 0.10000000149011612) * 10 equals about 7.00000025331974, which also truncates to int(7).
+A: Yes.
+0.6 is represented as 0.6000000238418579, and (0.6000000238418579 + 0.10000000149011612) * 10 equals about 7.00000025331974, which also truncates to int(7).
 
 **Q: Why do var_dump and echo show the expected value while intval/int casting does not?**
-A: When using echo, var_dump, or mathematical operations, PHP automatically adjusts the displayed values. However, intval and casting to int operate on the underlying bits before those values were adjusted, which is why they can produce a different (truncated) result.
+A: When using echo, var_dump, or mathematical operations, PHP automatically adjusts the displayed values.
+However, intval and casting to int operate on the underlying bits before those values were adjusted, which is why they can produce a different (truncated) result.
 
 **Q: How are floating-point numbers represented at the CPU level?**
-A: The CPU performs calculations in binary. IEEE Short Real (single precision) uses 32 bits: 1 sign bit, 8 exponent bits, and 23 mantissa bits. IEEE Long Real (double precision) uses 64 bits: 1 sign bit, 11 exponent bits, and 52 mantissa bits. A number can only be represented exactly if it can be expressed as exponent * mantissa; numbers like 0.99999999 cannot be represented exactly.
+A: The CPU performs calculations in binary.
+IEEE Short Real (single precision) uses 32 bits: 1 sign bit, 8 exponent bits, and 23 mantissa bits.
+IEEE Long Real (double precision) uses 64 bits: 1 sign bit, 11 exponent bits, and 52 mantissa bits.
+A number can only be represented exactly if it can be expressed as exponent * mantissa; numbers like 0.99999999 cannot be represented exactly.
 
 **Q: Is there a way to get accurate results for calculations like this in PHP?**
 A: If precise values matter for your project, the article recommends using the BCMath PHP Extension to get correct results.
+
+## Resources
+
+- [Floating point tutorial (kipirvine.com)](http://kipirvine.com/asm/workbook/floating_tut.htm)
+- [IEEE 754 converter (h-schmidt.net)](http://www.h-schmidt.net/FloatConverter/IEEE754.html)
+- [BCMath PHP Extension documentation](http://php.net/manual/en/book.bc.php)
+- [What Every Computer Scientist Should Know About Floating-Point Arithmetic](http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html)
diff --git a/public/md-articles/php-development/how-to-upgrade-wamp-to-php-5-3-4.md b/public/md-articles/php-development/how-to-upgrade-wamp-to-php-5-3-4.md
index ab74e756..7b485373 100644
--- a/public/md-articles/php-development/how-to-upgrade-wamp-to-php-5-3-4.md
+++ b/public/md-articles/php-development/how-to-upgrade-wamp-to-php-5-3-4.md
@@ -11,65 +11,48 @@ language: "en"
 # How To Upgrade Wamp to PHP 5.3.4
 
 ## TL;DR
-A step-by-step guide to manually upgrading the PHP version used by a WAMP server to PHP 5.3.4, by downloading the VC6 Thread Safe build, copying over configuration files, and switching the active PHP version in WAMP.
-
-1.    Stop WAMP server.
-
-2.    Go to [windows.php.net](http://windows.php.net/download/) and download the the latests ZIPPED package for php5.3.4.
-
-Make sure it is the **VC6 Thread Safe build**. DO NOT DOWNLOAD THE INSTALLER.
-
-3.  Create a folder php5.3.4 into wamp/bin/php
-
-4.  Extract the downloaded zip to the newly created php5.3.4 folder
-
-5.  Copy the files:
-
--  *php.ini*
-
--  *phpForApache.ini*
-
--   *wampserver.conf*
-
-from your existing php5.3 (eg.   wamp/bin/php/php5.3.3) folder to the new php5.3.4 folder.
-
-6.  Open the files:
 
--   *php.ini*
-
--  *phpForApache.ini*
-
-and search/replace the string 5.3.3 with 5.3.4
-
-7.   Go to wamp/bin/apache/apache/apache2.2.11/bin and delete the file called *php.ini*
-
-8.   Restart WAMP server.
-
-9.   Choose php version 5.3.0
-
-10.   Restart WAMP server.
-
-11.   Now choose php version 5.3.4 .
-
-12.   Check if PEAR path is correct in php.ini , and modify accordingly.
-
-13.   Restart WAMP server.
+A step-by-step guide to manually upgrading the PHP version used by a WAMP server to PHP 5.3.4, by downloading the VC6 Thread Safe build, copying over configuration files, and switching the active PHP version in WAMP.
 
-14.   Enjoy.
+## Steps
+
+1. Stop the WAMP server.
+2. Go to [windows.php.net](http://windows.php.net/download/) and download the latest ZIPPED package for PHP 5.3.4.
+Make sure it is the **VC6 Thread Safe build** - do not download the installer.
+3. Create a folder `php5.3.4` inside `wamp/bin/php`.
+4. Extract the downloaded zip into the newly created `php5.3.4` folder.
+5. Copy the files `php.ini`, `phpForApache.ini`, and `wampserver.conf` from your existing PHP 5.3 folder (e.g. `wamp/bin/php/php5.3.3`) to the new `php5.3.4` folder.
+6. Open the files `php.ini` and `phpForApache.ini` and search/replace the string `5.3.3` with `5.3.4`.
+7. Go to `wamp/bin/apache/apache/apache2.2.11/bin` and delete the file called `php.ini`.
+8. Restart the WAMP server.
+9. Choose PHP version 5.3.0.
+10. Restart the WAMP server.
+11. Now choose PHP version 5.3.4.
+12. Check that the PEAR path is correct in `php.ini`, and modify accordingly.
+13. Restart the WAMP server.
+14. Enjoy.
 
 ## FAQ
 
 **Q: Where do I download the PHP 5.3.4 package for WAMP?**
-A: Download the latest ZIPPED package for PHP 5.3.4 from windows.php.net. Make sure it is the VC6 Thread Safe build, and do not download the installer.
+A: Download the latest ZIPPED package for PHP 5.3.4 from windows.php.net.
+Make sure it is the VC6 Thread Safe build, and do not download the installer.
 
 **Q: Where should the downloaded PHP 5.3.4 files be extracted?**
 A: Create a folder named php5.3.4 inside wamp/bin/php, then extract the downloaded zip into that newly created folder.
 
 **Q: Which configuration files need to be copied and edited when upgrading?**
-A: Copy php.ini, phpForApache.ini, and wampserver.conf from the existing php5.3 folder (e.g. wamp/bin/php/php5.3.3) into the new php5.3.4 folder. Then, in php.ini and phpForApache.ini, search and replace the string 5.3.3 with 5.3.4.
+A: Copy php.ini, phpForApache.ini, and wampserver.conf from the existing php5.3 folder (e.g. wamp/bin/php/php5.3.3) into the new php5.3.4 folder.
+Then, in php.ini and phpForApache.ini, search and replace the string 5.3.3 with 5.3.4.
 
 **Q: Is there anything to remove from the Apache folder before restarting WAMP?**
-A: Yes. Go to wamp/bin/apache/apache/apache2.2.11/bin and delete the file called php.ini, then restart the WAMP server.
+A: Yes.
+Go to wamp/bin/apache/apache/apache2.2.11/bin and delete the file called php.ini, then restart the WAMP server.
 
 **Q: How do I actually switch WAMP to the new PHP version after restarting?**
-A: After restarting WAMP, choose PHP version 5.3.0, restart WAMP server again, and then choose PHP version 5.3.4. Also check that the PEAR path is correct in php.ini and modify it accordingly, then restart WAMP server once more.
+A: After restarting WAMP, choose PHP version 5.3.0, restart WAMP server again, and then choose PHP version 5.3.4.
+Also check that the PEAR path is correct in php.ini and modify it accordingly, then restart WAMP server once more.
+
+## Resources
+
+- [windows.php.net downloads](http://windows.php.net/download/)
diff --git a/public/md-articles/php-development/mezzio-app-development-in-wsl2.md b/public/md-articles/php-development/mezzio-app-development-in-wsl2.md
index d99b9874..cbf36b48 100644
--- a/public/md-articles/php-development/mezzio-app-development-in-wsl2.md
+++ b/public/md-articles/php-development/mezzio-app-development-in-wsl2.md
@@ -11,43 +11,27 @@ language: "en"
 # Mezzio app development in WSL2
 
 ## TL;DR
-This article runs through the steps of installing a Mezzio application (Dotkernel API) in WSL2 and running it on Ubuntu 20.04 LTS, from installing WSL2 itself to configuring PHPStorm to work with the WSL2 file system.
-
-## Install a Mezzio app (Dotkernel API) using WSL2
-
-This article will run you through the steps of installing a Mezzio application (Dotkernel API) in **WSL2** and run it on **Ubuntu 20.04 LTS**.
-
-### Step 1:
-
-Make sure you have WSL2 installed on your machine by following [this guide](https://github.com/dotkernel/development/blob/main/wsl/README.md).
-
-### Step 2:
-
-Install **Ubuntu 20.0 LTS** inside **WLS2** as described [here](https://docs.dotkernel.org/development/v2/running/) (the current version of this guide covers AlmaLinux 9, the distro the WSL setup has since moved to).
 
-### Step 3:
-
-Create a virtualhost for your project using [this guide](https://docs.dotkernel.org/development/v2/virtualhosts/create-virtualhost/).
-
-### Step 4:
-
-Using your terminal, move into the virtualhost directory that you just created:
-
-```
-cd /home/your-username/projects/your-virtualhost
-```
+This article runs through the steps of installing a Mezzio application (Dotkernel API) in WSL2 and running it on Ubuntu 20.04 LTS, from installing WSL2 itself to configuring PHPStorm to work with the WSL2 file system.
 
-Install Dotkernel API, by following [this guide](https://github.com/dotkernel/api).
+## Steps
 
-Make sure your `data` and `log` directories are writable by changing their permissions, as described [here](https://docs.dotkernel.org/development/v2/faq/#how-do-i-fix-common-permission-issues).
+1. Make sure WSL2 is installed on your machine, following the [WSL2 installation guide](https://github.com/dotkernel/development/blob/main/wsl/README.md).
+2. Install Ubuntu 20.04 LTS inside WSL2, as described in the [Ubuntu 20 setup guide](https://docs.dotkernel.org/development/v2/running/) (the current version of this guide covers AlmaLinux 9, the distro the WSL setup has since moved to).
+3. Create a virtual host for your project using the [virtual hosts guide](https://docs.dotkernel.org/development/v2/virtualhosts/create-virtualhost/).
+4. Using your terminal, move into the virtual host directory you just created:
 
-### Step 5:
+   ```shell
+   cd /home/your-username/projects/your-virtualhost
+   ```
 
-Setup PHPStorm to work with WSL2 files like in [this article](https://www.jetbrains.com/help/phpstorm/how-to-use-wsl-development-environment-in-product.html)
+Install Dotkernel API by following the [Dotkernel API guide](https://github.com/dotkernel/api).
+Make sure the `data` and `log` directories are writable by changing their permissions, as described in the [common permission issues guide](https://docs.dotkernel.org/development/v2/faq/#how-do-i-fix-common-permission-issues).
+5. Set up PHPStorm to work with WSL2 files, as described in the [JetBrains WSL development environment article](https://www.jetbrains.com/help/phpstorm/how-to-use-wsl-development-environment-in-product.html).
 
-**Note:**
+## Note
 
-> There is a guide for **AlmaLinux 8** as well, but that's not fully functional because of a well-known issue regarding running *systemd* inside **WSL2**.
+There is a guide for AlmaLinux 8 as well, but it is not fully functional because of a well-known issue regarding running systemd inside WSL2.
 
 ## FAQ
 
@@ -61,10 +45,20 @@ A: You first need WSL2 installed on your machine, which you can set up by follow
 A: After Ubuntu is installed inside WSL2, you create a virtual host for your project by following the linked virtual-host creation guide.
 
 **Q: How do you install Dotkernel API once the virtual host is ready?**
-A: Using your terminal, move into the virtual host directory you created (for example, cd /home/your-username/projects/your-virtualhost), then install Dotkernel API by following its guide. Afterward, make sure the data and log directories are writable by changing their permissions, as described in the linked permission-fix guide.
+A: Using your terminal, move into the virtual host directory you created (for example, `cd /home/your-username/projects/your-virtualhost`), then install Dotkernel API by following its guide.
+Afterward, make sure the `data` and `log` directories are writable by changing their permissions, as described in the linked permission-fix guide.
 
 **Q: How do you get PHPStorm to work with the WSL2 project files?**
 A: You set up PHPStorm to work with WSL2 files by following the linked JetBrains article on using a WSL development environment in the product.
 
 **Q: Does this guide also work for AlmaLinux instead of Ubuntu?**
 A: There is a guide for AlmaLinux 8 as well, but it is not fully functional because of a well-known issue regarding running systemd inside WSL2.
+
+## Resources
+
+- [WSL2 installation guide](https://github.com/dotkernel/development/blob/main/wsl/README.md)
+- [Ubuntu 20 setup inside WSL2](https://docs.dotkernel.org/development/v2/running/)
+- [Create virtual hosts guide](https://docs.dotkernel.org/development/v2/virtualhosts/create-virtualhost/)
+- [Dotkernel API installation guide](https://github.com/dotkernel/api)
+- [Fix common permission issues](https://docs.dotkernel.org/development/v2/faq/#how-do-i-fix-common-permission-issues)
+- [Using WSL development environment in PHPStorm](https://www.jetbrains.com/help/phpstorm/how-to-use-wsl-development-environment-in-product.html)
diff --git a/public/md-articles/php-development/php-5-3-6-released-no-upgrade-possible-for-wampserver.md b/public/md-articles/php-development/php-5-3-6-released-no-upgrade-possible-for-wampserver.md
index f9815ac5..72500d20 100644
--- a/public/md-articles/php-development/php-5-3-6-released-no-upgrade-possible-for-wampserver.md
+++ b/public/md-articles/php-development/php-5-3-6-released-no-upgrade-possible-for-wampserver.md
@@ -10,18 +10,22 @@ language: "en"
 
 # PHP 5.3.6 released. No upgrade possible for WampServer.
 
-PHP 5.3.6 was released, but it come with a bad news for WampServer users:
+PHP 5.3.6 was released, but it comes with bad news for WampServer users.
+The release notes state:
 
-> "Windows users: please mind that we do no longer provide builds created with Visual Studio C++ 6"
+> Windows users: please mind that we do no longer provide builds created with Visual Studio C++ 6
 
-Since WampServer is built using VC++ 6,  is not possible an upgrade , without a rewrite from scratch of entire WampServer package.
-
-More details on WampServer forum  **[here](http://www.wampserver.com/phorum/read.php?2,72243)**
+Since WampServer is built using VC++ 6, an upgrade isn't possible without a rewrite of the entire WampServer package from scratch.
 
 ## FAQ
 
 **Q: Why can't WampServer users upgrade to PHP 5.3.6?**
-A: PHP 5.3.6 no longer provides builds created with Visual Studio C++ 6 for Windows users. Since WampServer is built using VC++ 6, upgrading isn't possible without rewriting the entire WampServer package from scratch.
+A: PHP 5.3.6 no longer provides builds created with Visual Studio C++ 6 for Windows users.
+Since WampServer is built using VC++ 6, upgrading isn't possible without rewriting the entire WampServer package from scratch.
 
 **Q: Where can WampServer users find more details about this issue?**
 A: More details are available on the WampServer forum, linked in this article.
+
+## Resources
+
+- [WampServer forum discussion](http://www.wampserver.com/phorum/read.php?2,72243)
diff --git a/public/md-articles/php-development/php-environment-development-staging-production.md b/public/md-articles/php-development/php-environment-development-staging-production.md
index f4afd0ce..1100c3d2 100644
--- a/public/md-articles/php-development/php-environment-development-staging-production.md
+++ b/public/md-articles/php-development/php-environment-development-staging-production.md
@@ -11,42 +11,48 @@ language: "en"
 # PHP Environment : Development Staging Production
 
 ## TL;DR
+
 In hosted software development, an environment is a server tier designated to a specific stage of a release process.
 The three most common environments are Development, Staging and Production, and applications are typically moved between them using Subversion source control.
 
-In hosted software development, the environment refers to a server tier designated to a specific stage in a release process. The purpose of these environments is to improve the development, testing and release processes in client-server applications. The most common environments are described below.
-
 ## Development
 
-This is where the software is developed – it’s *the working environment for individual developers* or small teams. The purpose of this environment is for the developer to work on local host, separate from the rest of the team, allowing them to make various changes without worrying that it may alter the work of the other members of the team.
+This is where the software is developed - it's the working environment for individual developers or small teams. Its purpose is for the developer to work on local host, separate from the rest of the team, allowing them to make changes without worrying that it may alter the work of other team members.
 
 ## Staging
 
-It is *used to assemble, test and review the application before it goes into production*. Usually the staging environment tries to simulate as much as possible the production environment (hardware and software-wise). Normally, before releasing an update version of the application on the production environment, the update must be tested on the staging environment. This environment can also be used as a demonstration/training environment.
+Staging is used to assemble, test and review the application before it goes into production.
+It usually tries to simulate the production environment as much as possible, both hardware- and software-wise.
+Normally, before releasing an update to the production environment, the update must be tested on staging first. This environment can also be used as a demonstration or training environment.
 
 ## Production
 
-It is *the “live” environment*, where the final application goes out to the world and becomes active.
-
-To switch from one environment to another use the ***Subversion*** *source code*.
+Production is the "live" environment, where the final application goes out to the world and becomes active.
 
-Using SVN on Aptana is an article that explains how to set your *development* environment on your local computer and then to change it on your *staging* environment.
+## Switching between environments
 
-To better understand the development of an application using environments, check this helpful article [http://dltj.org/article/software-development-practice/](http://dltj.org/article/software-development-practice/)
+To switch from one environment to another, the article recommends using Subversion (SVN) source code.
+The "Using SVN on Aptana" article explains how to set up a development environment on a local computer and then move it to a staging environment.
 
 ## FAQ
 
 **Q: What is a "server environment" in hosted software development?**
-A: It refers to a server tier designated to a specific stage in a release process. The purpose of using different environments is to improve the development, testing and release processes in client-server applications.
+A: It refers to a server tier designated to a specific stage in a release process.
+The purpose of using different environments is to improve the development, testing and release processes in client-server applications.
 
 **Q: What is the development environment used for?**
 A: It's the working environment for individual developers or small teams, where the developer works on local host, separate from the rest of the team, allowing changes to be made without worrying about altering the work of other team members.
 
 **Q: What is the staging environment used for?**
-A: It's used to assemble, test and review the application before it goes into production, and it usually tries to simulate the production environment as closely as possible, both hardware- and software-wise. Before releasing an update to production, it must normally be tested on staging first, which can also serve as a demonstration or training environment.
+A: It's used to assemble, test and review the application before it goes into production, and it usually tries to simulate the production environment as closely as possible, both hardware- and software-wise.
+Before releasing an update to production, it must normally be tested on staging first, which can also serve as a demonstration or training environment.
 
 **Q: What is the production environment?**
 A: It's the "live" environment, where the final application goes out to the world and becomes active.
 
 **Q: How do you switch an application from one environment to another?**
 A: The article recommends using Subversion source code to switch from one environment to another, and points to the "Using SVN on Aptana" article for details on setting up a development environment locally and then moving it to a staging environment.
+
+## Resources
+
+- [Software development practice](http://dltj.org/article/software-development-practice/)
diff --git a/public/md-articles/php-development/php-support-back-in-aptana-3-0.md b/public/md-articles/php-development/php-support-back-in-aptana-3-0.md
index 73ca9cdf..a44b0417 100644
--- a/public/md-articles/php-development/php-support-back-in-aptana-3-0.md
+++ b/public/md-articles/php-development/php-support-back-in-aptana-3-0.md
@@ -11,20 +11,27 @@ language: "en"
 # PHP support back in Aptana 3.0
 
 ## TL;DR
+
 Aptana 3.0, then in beta, was set to bring PHP support back - and this time it would be built directly into the Studio 3 core rather than shipped as a separate plugin.
 A PHP debugger was also announced, to arrive as a separate set of plugins a few weeks later.
 
-Aptana 3.0 is in beta stage, can be downloaded from the [official site](http://www.aptana.com/products/studio3) .
+## The announcement
+
+Aptana 3.0 was in beta stage at the time of writing, available for download from the official Aptana site.
+
+The good news, based on an announcement from Aptana's own forum, was that Aptana PHP support was coming back - and would be integrated into Studio 3 core, not delivered as a separate plugin.
 
-The very super good news is that Aptana PHP Support is back , based on an annoucement from their [forum](https://aptanastudio.tenderapp.com/discussions/questions/419-php-in-studio-3). And even more,  will be integrated in Studio 3 core, not as a separate plugin.
+Aptana's Shalom G. shared the following in the forum announcement:
 
-> Aptana PHP is coming back. We are in the process of developing and integrating it into the Studio 3. The debugger will also be introduced, but it will take a few weeks till you'll be able to get it.
-> 
-> At the moment, the idea is to provide the PHP debugger as a separate set of plugins that you will be able to grab from the Studio. The majority of the PHP editing capabilities will be integrated into, and delivered with, the Studio core.
-> 
-> Cheers, -Shalom G
-> 
-> p.s. You can follow us on twitter for any major announcements, or follow me 'sgibly' for more frequent progress updates.
+> Aptana PHP is coming back.
+> We are in the process of developing and integrating it into the Studio 3.
+> The debugger will also be introduced, but it will take a few weeks till you'll be able to get it.
+>
+> At the moment, the idea is to provide the PHP debugger as a separate set of plugins that you will be able to grab from the Studio.
+> The majority of the PHP editing capabilities will be integrated into, and delivered with, the Studio core.
+>
+> Cheers,
+> -Shalom G
 
 ## FAQ
 
@@ -35,4 +42,10 @@ A: Aptana 3.0 is in beta stage and can be downloaded from the official Aptana si
 A: No. According to an announcement on Aptana's forum, PHP support is coming back and is being developed and integrated directly into the Studio 3 core, rather than delivered as a separate plugin.
 
 **Q: What about the PHP debugger?**
-A: The debugger will also be introduced, but it will take a few weeks to become available. The plan is to provide the PHP debugger as a separate set of plugins you can grab from the Studio, while the majority of the PHP editing capabilities will be integrated into and delivered with the Studio core.
+A: The debugger will also be introduced, but it will take a few weeks to become available.
+The plan is to provide the PHP debugger as a separate set of plugins you can grab from the Studio, while the majority of the PHP editing capabilities will be integrated into and delivered with the Studio core.
+
+## Resources
+
+- [Aptana Studio 3 official product page](http://www.aptana.com/products/studio3)
+- [Aptana forum announcement thread](https://aptanastudio.tenderapp.com/discussions/questions/419-php-in-studio-3)
diff --git a/public/md-articles/php-development/protection-against-sql-injection-using-pdo-and-zend-framework-part-2.md b/public/md-articles/php-development/protection-against-sql-injection-using-pdo-and-zend-framework-part-2.md
index 12f4d0cc..a293d151 100644
--- a/public/md-articles/php-development/protection-against-sql-injection-using-pdo-and-zend-framework-part-2.md
+++ b/public/md-articles/php-development/protection-against-sql-injection-using-pdo-and-zend-framework-part-2.md
@@ -11,39 +11,38 @@ language: "en"
 # Protection against SQL Injection using PDO and Zend Framework - part 2
 
 ## TL;DR
+
 Following up on the earlier SQL Injection article, this part digs into the specific methods of Zend_Db (and related classes Zend_Db_Statement, Zend_Db_Select, Zend_Db_Tables) to show exactly when their use of prepared statements does, and does not, protect against SQL injection - and offers a quick type-casting tip for WHERE clauses.
 
-Following the preview article about [SQL Injection](http://www.dotkernel.com/php-development/protection-against-sql-injection-using-pdo-and-zend-framework/), here is more - a strong argument why you should use Zend Framework for handling database access. *Zend_Db* is the primary class used for access the database, but there is more: *Zend_Db_Statement*, *Zend_Db_Select* and *Zend_Db_Tables*. What you should know about their methods is:
+## Zend_Db and related classes
 
-- *[query](https://docs.laminas.dev/laminas-db/adapter/#query-execution) (mixed $sql, [mixed $bind = array()])*
-  - use prepare statements internally
-  - but SQL Injection is still possible if $sql is dynamically created
-- *[fetchAll](https://docs.laminas.dev/laminas-db/adapter/#query-execution) (string|Zend_Db_Select $sql, , )*
-  - all the fetch methods are using prepared statements internally
-  - but SQL Injection is still possible if $sql is dynamically created
-- *[insert](https://docs.laminas.dev/laminas-db/sql/#insert) (mixed $table,  $bind)*
-  - use prepare statements internally
-  - so, SQL Injection is not possible
-- *[update](https://docs.laminas.dev/laminas-db/sql/#update) (mixed $table,  $bind, [mixed $where = ''])*
-  - use prepare statements internally
-  - but SQL Injection may be possible if $where is created dynamically
-- *[delete](https://docs.laminas.dev/laminas-db/sql/#delete) (mixed $table, [mixed $where = ''])*
-  - SQL Injection may be possible if $where is created dynamically
+Zend_Db is the primary class used for accessing the database, but there is more: Zend_Db_Statement, Zend_Db_Select and Zend_Db_Tables.
 
-***Note*:*** even if you use prepared statements using *Zend_Db* methods, SQL Injection is still possible if *WHERE* and *ORDER BY* clause are wrongly written, so pay attention to them.
+## What you should know about their methods
 
-For more details see [Stefan Esser slides](http://www.suspekt.org/downloads/DPC_Secure_Programming_With_The_Zend_Framework.pdf).
+| Method | Behavior |
+| --- | --- |
+| `query(mixed $sql, ...)` | Uses prepared statements internally, but SQL Injection is still possible if `$sql` is dynamically created. |
+| `fetchAll(string\|Zend_Db_Select $sql, ...)` | All the fetch methods use prepared statements internally, but SQL Injection is still possible if `$sql` is dynamically created. |
+| `insert(mixed $table, $bind)` | Uses prepared statements internally, so SQL Injection is not possible. |
+| `update(mixed $table, $bind, ...)` | Uses prepared statements internally, but SQL Injection may be possible if `$where` is created dynamically. |
+| `delete(mixed $table, ...)` | SQL Injection may be possible if `$where` is created dynamically. |
 
-PS. A short [tip](https://www.w3schools.com/php/php_casting.asp), you can use cast type to avoid SQL Injection in WHERE clause where is possible.
+**Note:** even if you use prepared statements via Zend_Db methods, SQL Injection is still possible if the `WHERE` and `ORDER BY` clauses are wrongly written, so pay attention to them.
 
-```
-$sql= 'SELECT * FROM table WHERE id = ' . (int)$_POST['id'];
+## A quick tip for WHERE clauses
+
+A short tip: you can use type casting to avoid SQL Injection in a WHERE clause where possible.
+
+```php
+$sql = 'SELECT * FROM table WHERE id = ' . (int)$_POST['id'];
 ```
 
 ## FAQ
 
 **Q: What is the focus of this article?**
-A: Following the earlier article about SQL Injection, this article makes a stronger argument for using Zend Framework to handle database access. Zend_Db is the primary class used for accessing the database, but there is more to it: Zend_Db_Statement, Zend_Db_Select, and Zend_Db_Tables.
+A: Following the earlier article about SQL Injection, this article makes a stronger argument for using Zend Framework to handle database access.
+Zend_Db is the primary class used for accessing the database, but there is more to it: Zend_Db_Statement, Zend_Db_Select, and Zend_Db_Tables.
 
 **Q: Does Zend_Db's query() method protect against SQL injection?**
 A: query() uses prepared statements internally, but SQL Injection is still possible if the $sql parameter passed to it is dynamically created.
@@ -55,7 +54,15 @@ A: All of the fetch methods use prepared statements internally, but SQL Injectio
 A: Yes. insert() uses prepared statements internally, so SQL Injection is not possible with it.
 
 **Q: What about update() and delete()?**
-A: update() uses prepared statements internally, but SQL Injection may be possible if the $where clause is created dynamically. Likewise, with delete(), SQL Injection may be possible if $where is created dynamically.
+A: update() uses prepared statements internally, but SQL Injection may be possible if the $where clause is created dynamically.
+Likewise, with delete(), SQL Injection may be possible if $where is created dynamically.
 
 **Q: Even with prepared statements, when can SQL injection still happen, and what tip helps avoid it in WHERE clauses?**
-A: Even when using prepared statements via Zend_Db methods, SQL Injection is still possible if the WHERE and ORDER BY clauses are wrongly written, so these deserve special attention. A short tip mentioned is to use type casting to avoid SQL Injection in a WHERE clause where possible, for example: $sql = 'SELECT * FROM table WHERE id = ' . (int)$_POST;
+A: Even when using prepared statements via Zend_Db methods, SQL Injection is still possible if the WHERE and ORDER BY clauses are wrongly written, so these deserve special attention.
+A short tip mentioned is to use type casting to avoid SQL Injection in a WHERE clause where possible, for example: `$sql = 'SELECT * FROM table WHERE id = ' . (int)$_POST;`
+
+## Resources
+
+- [Protection against SQL Injection using PDO and Zend Framework (part 1)](http://www.dotkernel.com/php-development/protection-against-sql-injection-using-pdo-and-zend-framework/)
+- [Secure Programming with the Zend Framework (Stefan Esser slides)](http://www.suspekt.org/downloads/DPC_Secure_Programming_With_The_Zend_Framework.pdf)
+- [PHP Type Casting](https://www.w3schools.com/php/php_casting.asp)
diff --git a/public/md-articles/php-development/protection-against-sql-injection-using-pdo-and-zend-framework.md b/public/md-articles/php-development/protection-against-sql-injection-using-pdo-and-zend-framework.md
index 54a1be3f..105b17ec 100644
--- a/public/md-articles/php-development/protection-against-sql-injection-using-pdo-and-zend-framework.md
+++ b/public/md-articles/php-development/protection-against-sql-injection-using-pdo-and-zend-framework.md
@@ -11,36 +11,78 @@ language: "en"
 # Protection against SQL Injection using PDO and Zend Framework
 
 ## TL;DR
+
 SQL injection exploits unfiltered user input passed into SQL statements.
 PDO (PHP Data Objects) is a standardized database access layer that provides a data-access abstraction (not a database abstraction) and offers several benefits, including help protecting against SQL injection.
 In Zend Framework, prepared statements are encouraged since they handle parameter escaping, but they are not a complete guarantee against SQL injection - especially with PDO_MySQL, and with WHERE IN / ORDER BY clauses.
 
-SQL injection is a technique that exploits a security vulnerability occurring in the database layer of an application. Usually, *user input is not filtered by the script and is passed into a SQL statement.*
+## What is SQL injection?
+
+SQL injection is a technique that exploits a security vulnerability occurring in the database layer of an application.
+Usually, user input is not filtered by the script and is passed into a SQL statement.
+
+## What is PDO?
+
+PDO - PHP Data Objects - is a database access layer providing a standardized method of access to multiple databases.
+PDO provides a data-access abstraction layer, meaning that regardless of which database you're using, you apply the same functions to issue queries and fetch data.
+PDO does not provide a database abstraction; it doesn't rewrite SQL or emulate missing features.
+
+Among PDO's benefits are:
 
-**PDO – PHP Data Objects** – is a database access layer providing a standardized method of access to multiple databases.  PDO provides a *data-access abstraction layer*, meaning that depending on what database you're using, you will have apply the same functions to issue queries and fetch data. ***PDO does not provide a database abstraction;*** it doesn't rewrite SQL or emulate missing features. Among  PDO benefits there are: -    Access methods allow complete control over how attributes are read and written -    Validation on a per-record and per-attribute level -    Easier fetching of objects from related table -    Reusable logic - means that the same codebase is much easier to maintain -    Cleaner code by using object oriented code -    Less errors from SQL query generation -    Last but not least : Protection against SQL injection
+- Access methods that allow complete control over how attributes are read and written
+- Validation on a per-record and per-attribute level
+- Easier fetching of objects from related tables
+- Reusable logic - the same codebase is much easier to maintain
+- Cleaner code by using object-oriented code
+- Fewer errors from SQL query generation
+- Protection against SQL injection
 
-In Zend Framework for database access, methods usually support prepared statements. Dynamic SQL queries are allowed, but you must escape all the parameter, otherwise you have SQL injection.  ***Because of this, prepared statements are encouraged to be used. They can handle escaping parameters for you.*** Most people believe that using prepared statements they are 100% protected from SQL injection. But this is by far true. Input data should always be validated and sanitized, and PDO should be seen as another line of defense. PDO is not protecting you from other security vulnerabilities like XSS*(cross-site scripting)*, but helps protect your application against SQL injection.
+## Prepared statements in Zend Framework
 
-It may also occur a problem in Zend Framework w*hen you have SQL injection in your application while you are using PDO_MySQL.* ***PDO_MySQL is a more dangerous application than any other traditional MySQL applications. Traditional MySQL allows only a single SQL query. In PDO_MySQL there is no such limitation, but you risk to be injected with multiple queries.*** To avoid this you should try to use the correct prepared statements from Zend Framework. You should also pay attention when you have in your SQL query *WHERE IN* and *ORDER BY;* they cannot be handled by prepare statements normally. In this case you should escape your data.
+In Zend Framework, database access methods usually support prepared statements.
+Dynamic SQL queries are allowed, but all parameters must be escaped, otherwise SQL injection is possible.
+Because of this, prepared statements are encouraged, since they handle escaping parameters for you.
 
-Zend_Db has two escaping methods which can be used: *quote()* and *quoteIdentifier()*. Note that these two methods are handling strings by putting them between single quotes.
+Most people believe that using prepared statements makes them 100% protected from SQL injection, but this is not true.
+Input data should always be validated and sanitized, and PDO should be seen as another line of defense.
+PDO does not protect against other security vulnerabilities like XSS (cross-site scripting), but it does help protect an application against SQL injection.
+
+## The PDO_MySQL risk
+
+A problem can occur in Zend Framework where SQL injection is possible even while using PDO_MySQL.
+PDO_MySQL is more dangerous than traditional MySQL applications: traditional MySQL allows only a single SQL query, while PDO_MySQL has no such limitation, so there is a risk of being injected with multiple queries.
+To avoid this, use the correct prepared statements provided by Zend Framework.
+Also pay attention when your SQL query has `WHERE IN` and `ORDER BY` clauses, since these cannot normally be handled correctly by prepared statements - in this case, escape the data instead.
+
+Zend_Db provides two escaping methods for this purpose: `quote()` and `quoteIdentifier()`.
+Both handle strings by putting them between single quotes.
 
 ## FAQ
 
 **Q: What is SQL injection?**
-A: SQL injection is a technique that exploits a security vulnerability occurring in the database layer of an application. Usually, user input is not filtered by the script and is passed directly into a SQL statement.
+A: SQL injection is a technique that exploits a security vulnerability occurring in the database layer of an application.
+Usually, user input is not filtered by the script and is passed directly into a SQL statement.
 
 **Q: What is PDO and what kind of abstraction does it provide?**
-A: PDO (PHP Data Objects) is a database access layer providing a standardized method of access to multiple databases. It provides a data-access abstraction layer, meaning you apply the same functions to issue queries and fetch data regardless of which database you're using. However, PDO does not provide a database abstraction - it doesn't rewrite SQL or emulate missing database features.
+A: PDO (PHP Data Objects) is a database access layer providing a standardized method of access to multiple databases.
+It provides a data-access abstraction layer, meaning you apply the same functions to issue queries and fetch data regardless of which database you're using.
+However, PDO does not provide a database abstraction - it doesn't rewrite SQL or emulate missing database features.
 
 **Q: What are the benefits of using PDO?**
 A: Among the benefits are: access methods that allow complete control over how attributes are read and written, validation on a per-record and per-attribute level, easier fetching of objects from related tables, reusable logic that makes the codebase easier to maintain, cleaner code through object-oriented programming, fewer errors from SQL query generation, and protection against SQL injection.
 
 **Q: Does using prepared statements in Zend Framework fully protect against SQL injection?**
-A: Not entirely. Zend Framework's database access methods usually support prepared statements, which are encouraged because they handle escaping parameters for you, but dynamic SQL queries are still allowed and any parameters must be escaped manually or SQL injection becomes possible. Many people believe prepared statements offer 100% protection, but this isn't true - input data should always be validated and sanitized, with PDO treated as another line of defense. PDO also does not protect against other vulnerabilities such as XSS (cross-site scripting).
+A: Not entirely.
+Zend Framework's database access methods usually support prepared statements, which are encouraged because they handle escaping parameters for you, but dynamic SQL queries are still allowed and any parameters must be escaped manually or SQL injection becomes possible.
+Many people believe prepared statements offer 100% protection, but this isn't true - input data should always be validated and sanitized, with PDO treated as another line of defense.
+PDO also does not protect against other vulnerabilities such as XSS (cross-site scripting).
 
 **Q: Why can PDO_MySQL be riskier than traditional MySQL usage, and how can this be avoided?**
-A: Traditional MySQL allows only a single SQL query at a time, but PDO_MySQL has no such limitation, meaning there is more risk of being injected with multiple queries. To avoid this, you should use the correct prepared statements from Zend Framework, and pay particular attention to WHERE IN and ORDER BY clauses, since they aren't normally handled correctly by prepared statements - in these cases you should escape the data yourself.
+A: Traditional MySQL allows only a single SQL query at a time, but PDO_MySQL has no such limitation, meaning there is more risk of being injected with multiple queries.
+To avoid this, you should use the correct prepared statements from Zend Framework, and pay particular attention to WHERE IN and ORDER BY clauses, since they aren't normally handled correctly by prepared statements - in these cases you should escape the data yourself.
 
 **Q: What escaping methods does Zend_Db provide?**
-A: Zend_Db has two escaping methods that can be used: quote() and quoteIdentifier(). Both of these methods handle strings by putting them between single quotes.
+A: Zend_Db has two escaping methods that can be used: quote() and quoteIdentifier().
+Both of these methods handle strings by putting them between single quotes.
+
+
diff --git a/public/md-articles/php-development/remote-connections-to-mysql-server-on-plesk-based-servers.md b/public/md-articles/php-development/remote-connections-to-mysql-server-on-plesk-based-servers.md
index d2679f63..3a5f896d 100644
--- a/public/md-articles/php-development/remote-connections-to-mysql-server-on-plesk-based-servers.md
+++ b/public/md-articles/php-development/remote-connections-to-mysql-server-on-plesk-based-servers.md
@@ -11,46 +11,39 @@ language: "en"
 # Remote connections to MySQL server on Plesk based servers
 
 ## TL;DR
+
 Plesk-based Linux servers default to `old_passwords=1`, which forces MySQL to use the old, pre-4.1 password storage style even on MySQL 5.5+, breaking remote PDO connections.
 The fix is to create a new database user, grant it privileges, disable old_passwords, and reset its password so a newer, longer password hash is stored in mysql.user.
 
-By default, MySql servers on Linux machines where Plesk is installed, have the **old_passwords**=1 or ON flag.
-
-That mean even if you have MySQL 5.5+ version, it still use old style of password storage, pre-mysql 4.1+
-
+By default, MySql servers on Linux machines where Plesk is installed, have the old_passwords=1 or ON flag.
+That mean even if you have MySQL 5.5+ version, it still use old style of password storage, pre-mysql 4.1+.
 If you try to connect remote, from your local development machine, you will get an ugly error, like:
 
- 
-
 ```
 Fatal error: Uncaught exception 'PDOException' with message 'SQLSTATE  mysqlnd
-cannot connect  to MySQL 4.1+ using the old insecure authentication. Please use an administration
+cannot connect  to MySQL 4.1+ using the old insecure authentication. Please use an administration
 tool to reset your password with the command SET PASSWORD = PASSWORD('your_existing_password').
 This will store a new, and more secure, hash value in mysql.user.
 If this user is used in other scripts executed by PHP 5.2 or earlier you might need to remove
- the old-passwords flag from your my.cnf file' in
+the old-passwords flag from your my.cnf file' in
 ```
 
-How to fix that [ You need mysql admin priviledges] :
+How to fix that:
 
-1. Create a new database user,  **someuser** for instance directly in command line
+1. Create a new database user, someuser for instance directly in command line.
 2. Grant priviledges to that user to the database you want to connect to.
 3. Now run the below SQL statements:
 
-```
+```sql
 SET old_passwords = 0;
 UPDATE mysql.user SET Password = PASSWORD('somepassword') WHERE User = 'someuser' limit 1;
 SELECT LENGTH(Password) FROM mysql.user WHERE User = 'someuser';
 FLUSH PRIVILEGES;
 ```
 
- 
-
-Now you can remotely connect to that server, using the user: **someuser** and password: **somepassword**
-
- 
+Now you can remotely connect to that server, using the user: someuser and password: somepassword.
 
-NOTE: if you browse the table mysql.user , you will note that the password field contain many more characters for the user **someuser** compared to the others.
+NOTE: if you browse the table mysql.user, you will note that the password field contain many more characters for the user someuser compared to the others.
 
 ## FAQ
 
diff --git a/public/md-articles/php-development/static-analysis-replacing-psalm-with-phpstan.md b/public/md-articles/php-development/static-analysis-replacing-psalm-with-phpstan.md
index 3dc05ccc..d6f6a615 100644
--- a/public/md-articles/php-development/static-analysis-replacing-psalm-with-phpstan.md
+++ b/public/md-articles/php-development/static-analysis-replacing-psalm-with-phpstan.md
@@ -11,17 +11,19 @@ language: "en"
 # Static Analysis - Replacing Psalm with PHPStan
 
 ## TL;DR
+
 Dotkernel is replacing Psalm with PHPStan for static analysis, following a broader PHP community shift (including projects like Doctrine and Composer) toward PHPStan's faster-growing ecosystem, full-time maintainer, PHPStorm-based stubs, and stronger detection.
 This article explains what static analysis is, why the switch makes sense, and walks through updating composer.json, the CI workflow, and the phpstan.neon configuration to run PHPStan checks in place of Psalm.
 
-## What is Static Analysis
+## What Is Static Analysis
 
-**Static analysis** (static code analysis or source code analysis) applies a set of coding rules to **debug source code** before a program is run. Applied in the early phase of code development, the goals of static analysis are:
+Static analysis (static code analysis or source code analysis) applies a set of coding rules to debug source code before a program is run.
+Applied in the early phase of code development, the goals of static analysis are:
 
-- **Catch and fix errors** like type-related errors which can occur especially in dynamically-typed programming languages like PHP.
-- **Confirm coding standards** to ensure readability and maintainability for large projects that need a consistent coding style.
-- **Identify code that needs refactoring** and recommend improvements to improve complex or 'smelly' code.
-- **Enhance security** by detecting potential code injection in PHP, cross-site scripting (XSS) and open redirect vulnerabilities.
+- Catch and fix errors like type-related errors which can occur especially in dynamically-typed programming languages like PHP.
+- Confirm coding standards to ensure readability and maintainability for large projects that need a consistent coding style.
+- Identify code that needs refactoring and recommend improvements to improve complex or 'smelly' code.
+- Enhance security by detecting potential code injection in PHP, cross-site scripting (XSS) and open redirect vulnerabilities.
 
 The top static analysis tools are:
 
@@ -34,7 +36,9 @@ The top static analysis tools are:
 
 ## Why Switch from Psalm to PHPStan?
 
-Dotkernel has been using [psalm](https://psalm.dev/) for a while now and the results have always been positive. A large part of the PHP community, especially developers in widely-used projects like Doctrine and Composer, have opted for [PHPStan](https://phpstan.org/) instead. For most use cases, psalm and PHPStan have identical findings, so it isn't really justified to use both.
+Dotkernel has been using [psalm](https://psalm.dev/) for a while now and the results have always been positive.
+A large part of the PHP community, especially developers in widely-used projects like Doctrine and Composer, have opted for [PHPStan](https://phpstan.org/) instead.
+For most use cases, psalm and PHPStan have identical findings, so it isn't really justified to use both.
 
 PHPStan has some advantages to psalm:
 
@@ -48,7 +52,7 @@ Thus, the better choice becomes PHPStan.
 
 ## Updating Your Project to Use PHPStan
 
-First, remove the references to psalm
+First, remove the references to psalm:
 
 - update the `require` in your `composer.json` file
   - remove `vimeo/psalm`
@@ -90,7 +94,7 @@ jobs:
       - name: Install PHP
         uses: shivammathur/setup-php@v2
         with:
-          php-version: '${{ matrix.php }}'
+          php-version: "${{ matrix.php }}"
           coverage: pcov
           ini-values: assert.exception=1, zend.assertions=1, error_reporting=-1, log_errors_max_len=0, display_errors=On
           tools: composer:v2, cs2pr
@@ -135,18 +139,18 @@ parameters:
             path: test/Functional/AbstractFunctionalTest.php
 ```
 
-## Running the PHPStan checks
+## Running the PHPStan Checks
 
 To run the checks, use this command:
 
-```
+```bash
 composer static-analysis
 ```
 
-`composer.json` is currently set up to run this command which sets up the memory limit to a higher amount that that from the `php.ini` file in PHP (128M).
+`composer.json` is currently set up to run this command which sets up the memory limit to a higher amount than that from the `php.ini` file in PHP (128M).
 
-```
-vendor/bin/phpstan analyse --memory-limit 1G 
+```bash
+vendor/bin/phpstan analyse --memory-limit 1G
 ```
 
 If you still get the error below, try increasing the memory limit further, e.g. 2G or 4G.
@@ -157,7 +161,8 @@ Child process error: PHPStan process crashed because it reached configured PHP m
 
 ## Summary
 
-In this article we revisited the theoretical meaning of static analysis and focused on the change from psalm to PHPStan. It's highly recommended to use a static analysis tool in your project and, while both psalm and PHPStan perform similar functions, the latter has recently stepped ahead of the former.
+In this article we revisited the theoretical meaning of static analysis and focused on the change from psalm to PHPStan.
+It's highly recommended to use a static analysis tool in your project and, while both psalm and PHPStan perform similar functions, the latter has recently stepped ahead of the former.
 
 ## FAQ
 
diff --git a/public/md-articles/php-development/using-aptana-to-connect-to-dotkernel-tracker-mantis.md b/public/md-articles/php-development/using-aptana-to-connect-to-dotkernel-tracker-mantis.md
index 873be638..303553c0 100644
--- a/public/md-articles/php-development/using-aptana-to-connect-to-dotkernel-tracker-mantis.md
+++ b/public/md-articles/php-development/using-aptana-to-connect-to-dotkernel-tracker-mantis.md
@@ -11,48 +11,36 @@ language: "en"
 # Using Aptana to connect to Dotkernel tracker (Mantis)
 
 ## TL;DR
+
 This guide explains how to connect the Aptana IDE to Dotkernel Tracker, the Mantis-based bug tracker used for the Dotkernel application framework, via the Mylyn plugin's Mantis connector.
 It walks through installing Aptana and Mylyn, adding Dotkernel Tracker as a task repository, and validating the connection so tickets can be managed directly from the IDE.
 
-In developing **Dotkernel** application framework, we needed a tracking system. **[Dotkernel Tracker](http://www.dotkernel.net/)** is the place where the *bugs* are reported, new *features* are announced and other *general tickets* are added.
-
-**[Dotkernel Tracker](http://www.dotkernel.net/)** is a **[Mantis](http://www.mantisbt.org/)** web-based bugtracking system. To simplify the development of **Dotkernel**, we integrated our web development IDE – **[Aptana](http://www.aptana.com/)** with our bugtracking system – **[Dotkernel Tracker](http://www.dotkernel.net/)**. In the ***Downloads*** section, you will find screenshots with the below steps for **[Using Aptana with the Mylyn connector for Mantis](../download/?did=24)**
-
-**1.** Install **Aptana** 2.0.5 by following these steps: **[http://www.dotkernel.com/php-development/aptana-php-installation-in-aptana-2-x/](../php-development/aptana-php-installation-in-aptana-2-x/)**
-
-**2.** Install the **Mylyn** plugin:
-
-*Aptana* -> *Help* ->*Software Update*
-
-*Add***: [http://download.eclipse.org/tools/mylyn/update/e3.4/](http://download.eclipse.org/tools/mylyn/update/e3.4/)**
-
-**3.** *Aptana*- >*Windows* -> *Show View* -> *Other* -> *Task* *Repository*
-
-**4.** Right click: *Add* *Task* *Repository* -> *Install* *More* *Connectors*
-
-**5.** Select *Mantis* , then *Finish*
-
-**6.** Install ***Mylyn Connector*** *–* ***Mantis***
-
-**7.** From the *Task* *Repository* window, right click to select *Add* *Task* *Repository*-> *Mantis*->*Next*
-
-*Server* : **[http://www.dotkernel.net/api/soap/mantisconnect.php](http://www.dotkernel.net/api/soap/mantisconnect.php)**
-
-*Label*: **Dotkernel Tracker** (or a custom string )
-
-*User ID*: your username from **[http://www.dotkernel.net/](http://www.dotkernel.net/)**. If you don’t have an account, signup **[here](http://www.dotkernel.net/signup_page.php)**
-
-**8.** To check if your connection works, click on *Validate* *Settings*, then *Finish*
-
-**9.** A window will popup asking if you want to create a query;  click *Yes*
-
-**10.** *Select project**: Dotkernel***
-
-*Select filter: **[Build-in] Latest Dot Kernel tasks***
-
-*Query Title:* change title – optional
-
-*Finish*
+## Overview
+
+Dotkernel Tracker is a Mantis web-based bugtracking system where bugs are reported, new features are announced, and other general tickets are added.
+To simplify the development of Dotkernel, the Aptana IDE was integrated with the Dotkernel Tracker bugtracking system.
+Screenshots for the steps below are available in the Downloads section, under [Using Aptana with the Mylyn connector for Mantis](https://www.dotkernel.com/download/?did=24).
+
+## Steps
+
+1. Install Aptana 2.0.5 by following the steps at [http://www.dotkernel.com/php-development/aptana-php-installation-in-aptana-2-x/](https://www.dotkernel.com/php-development/aptana-php-installation-in-aptana-2-x/).
+2. Install the Mylyn plugin.
+Go to Aptana -> Help -> Software Update.
+Add the update site: [http://download.eclipse.org/tools/mylyn/update/e3.4/](http://download.eclipse.org/tools/mylyn/update/e3.4/).
+3. In Aptana, go to Windows -> Show View -> Other -> Task Repository.
+4. Right click and select Add Task Repository -> Install More Connectors.
+5. Select Mantis, then Finish.
+6. Install the Mylyn Connector for Mantis.
+7. From the Task Repository window, right click and select Add Task Repository -> Mantis -> Next.
+Server: [http://www.dotkernel.net/api/soap/mantisconnect.php](http://www.dotkernel.net/api/soap/mantisconnect.php).
+Label: Dotkernel Tracker (or a custom string).
+User ID: your username from [http://www.dotkernel.net/](http://www.dotkernel.net/) - if you don't have an account, [sign up here](http://www.dotkernel.net/signup_page.php).
+8. To check if your connection works, click Validate Settings, then Finish.
+9. A popup will ask if you want to create a query; click Yes.
+10. Select project: Dotkernel.
+Select filter: Latest Dot Kernel tasks.
+Query Title: change the title if desired (optional).
+Click Finish.
 
 ## FAQ
 
diff --git a/public/md-articles/php-development/using-php-7-express-in-zend-studio-13.md b/public/md-articles/php-development/using-php-7-express-in-zend-studio-13.md
index da633852..45a4a6f2 100644
--- a/public/md-articles/php-development/using-php-7-express-in-zend-studio-13.md
+++ b/public/md-articles/php-development/using-php-7-express-in-zend-studio-13.md
@@ -11,64 +11,58 @@ language: "en"
 # Using PHP 7 Express in Zend Studio 13
 
 ## TL;DR
+
 Zend Studio 13 introduces PHP 7 Express, a feature that checks whether pre-PHP7 code will run cleanly on a PHP7 server.
 This article walks through setting up a test project with the correct PHP version, verifying the PHP Interpreter setting, adding Zend Framework 1 to the project, and running PHP 7 Express to surface compatibility issues.
 
-This article will cover the steps needed in order to check the PHP7 compatibility, a small troubleshooter.
-
-This article will also contain a compatibility issue check on the latest Zend Framework 1 version.
-
-## What is PHP 7 Express?
-
-PHP 7 Express is the newest feature added in Zend Studio (from version 13). This feature is very useful for checking if your pre-PHP7 code will work on a PHP7 server.
+## What Is PHP 7 Express?
 
-## The project creation
+PHP 7 Express is the newest feature added in Zend Studio, starting with version 13.
+This feature is very useful for checking if your pre-PHP7 code will work on a PHP7 server.
 
-If you already have the project backup and you are sure you can modify your project you can skip this step.
+## The Project Creation
 
-If you want to create a new project for testing instead of modifying the original project make sure the PHP Version is set to PHP 5.6 or the PHP Version you use in the project. Choosing the PHP 7 option will hide the PHP 7 Express feature because Zend Studio assumes a PHP 7 project doesn't need compatibility checks, but if the project is using a different version of PHP compatibility issues might apper.
-
-Long story short: Use the exact PHP version your project is using at the project creation.
+If you already have the project backup and you are sure you can modify your project, you can skip this step.
+If you want to create a new project for testing instead of modifying the original project, make sure the PHP Version is set to PHP 5.6, or whichever PHP version you use in the project.
+Choosing the PHP 7 option will hide the PHP 7 Express feature, because Zend Studio assumes a PHP 7 project doesn't need compatibility checks, but if the project is actually using a different version of PHP, compatibility issues might appear.
+Long story short: use the exact PHP version your project is using at project creation.
 
 [![The New Local PHP Project dialog in Zend Studio 13](/uploads/article/019f8a80-cc69-7286-91c9-b075c0b9be59/Screenshot-2015-12-22-16.21.56.png)](/uploads/2015/12/Screenshot-2015-12-22-16.21.56.png) The "New Local PHP Project" dialog in Zend Studio 13 and the PHP version selection
 
-## The 'PHP Interpreter' selection
-
-If the **PHP 7 Express** feature is won't show up the issue might be the **PHP Interpreter** selected.
+## The 'PHP Interpreter' Selection
 
+If the PHP 7 Express feature won't show up, the issue might be the PHP Interpreter selected.
 To check and modify the PHP Interpreter:
 
-- right click the project
-- type "interpreter"
-- The **PHP** -> **Interpreter** option should show up
-- If you only need a specific interpreter for a specific project you can check "Enable Project specific settings" by checking this option you won't affect the other projects in the current workspace
+- Right click the project.
+- Type "interpreter".
+- The PHP -> Interpreter option should show up.
+- If you only need a specific interpreter for a specific project, check "Enable Project specific settings" - this way you won't affect the other projects in the current workspace.
 
 [![Zend Studio PHP Interpreter Dialog](/uploads/article/019f8a80-cc69-7286-91c9-b075c0b9be59/zftest.png)](/uploads/2015/12/zftest.png) Zend Studio PHP Interpreter Dialog
 
-The **PHP 7 Express** feature should now show up.
+The PHP 7 Express feature should now show up.
 
-## Project preparation
+## Project Preparation
 
-As we created a local project named **zend-framework-test** we will add the latest Zend Framework 1 version in our project.
+As an example, a local project named zend-framework-test is used, and the latest Zend Framework 1 version is added to it.
 
-- right click on the project
-- create a new folder named **library**
-- download the latest **Zend Framework 1** version from [here](http://framework.zend.com/downloads/latest#ZF1), make sure you choose the **Full** option, not the **Full Package** one
-- extract the archive and browse the **library** folder
-- copy the **Zend** folder in your project's **library** folder
-- if the Drag and Drop didn't work and you had to manually copy the folder in your project you can click the project folder in Zend Studio and just press **F5** (Refresh)
+- Right click on the project.
+- Create a new folder named library.
+- Download the latest Zend Framework 1 version from [here](http://framework.zend.com/downloads/latest#ZF1), making sure to choose the Full option, not the Full Package one.
+- Extract the archive and browse the library folder.
+- Copy the Zend folder into your project's library folder.
+- If the drag and drop didn't work and you had to manually copy the folder into your project, click the project folder in Zend Studio and press F5 (Refresh).
 
 ## Using PHP 7 Express - Testing Zend Framework 1
 
-Now let's see **PHP 7 Express** in action. Using PHP 7 Express is very easy:
-
-- right-click the **project,** not a folder or a file because the feature won't show up
-- click "**Run PHP 7 Express...**"
-- a confirmation prompt will be displayed
+Using PHP 7 Express is very easy:
 
-After the analysis was done, you should see the **PHP 7 Express** view (or tab) in the bottom pane in Zend Studio (this depends on the perspective).
+- Right-click the project, not a folder or a file, because the feature won't show up.
+- Click "Run PHP 7 Express...".
+- A confirmation prompt will be displayed.
 
-The result should look like this:
+After the analysis is done, the PHP 7 Express view (or tab) appears in the bottom pane in Zend Studio, depending on the perspective.
 
 [![Zend Framework 1 compatibility issues with PHP7](/uploads/article/019f8a80-cc69-7286-91c9-b075c0b9be59/php7errors.png)](/uploads/2015/12/php7errors.png) Zend Framework 1 compatibility issues with PHP7
 
diff --git a/public/md-articles/php-development/version-control-ignore-patterns-in-zend-studio.md b/public/md-articles/php-development/version-control-ignore-patterns-in-zend-studio.md
index 0003d4e0..5f2f8335 100644
--- a/public/md-articles/php-development/version-control-ignore-patterns-in-zend-studio.md
+++ b/public/md-articles/php-development/version-control-ignore-patterns-in-zend-studio.md
@@ -11,22 +11,20 @@ language: "en"
 # Version Control Ignore Patterns in Zend Studio
 
 ## TL;DR
+
 Zend Studio lets you manage "Ignored Resources" patterns globally, under Window -> Preferences -> Team -> Ignored Resources, instead of configuring them separately for each project.
 This is especially handy when a workspace mixes Git and SVN projects, though any given project can still opt to use its own specific patterns instead of the global ones.
 
-In order to globally manage the ["Ignored Resources"](http://www.dotkernel.com/best-practice/svn-keywords-setup-in-php-ide-zend-studio/)  patterns in Zend Studio, for all projects , instead of manually add to each project, you can do the following:
-
-1. Go to **Window**-> **Preferences**
-
-2. **Team** -> **Ignored Resources **
-
-3. using **Add Pattern,** you can add each ignored pattern , one by one . Or you can remove some of allready existing patterns.
+## Managing Global Ignored Resources
 
-This is specially useful when you have both Git and SVN projects in your workspace , also when you tend to be less careful about your code and workspace :-)
+In order to globally manage the [Ignored Resources](https://www.dotkernel.com/best-practice/svn-keywords-setup-in-php-ide-zend-studio/) patterns in Zend Studio for all projects, instead of manually adding them to each project, you can do the following:
 
-Also, on each project, you can use either global ignored  patterns, or use specific ones.
+1. Go to Window -> Preferences.
+2. Team -> Ignored Resources.
+3. Using Add Pattern, add each ignored pattern one by one, or remove some of the already existing patterns.
 
- 
+This is especially useful when you have both Git and SVN projects in your workspace, and also when you tend to be less careful about your code and workspace.
+Also, on each project, you can use either the global ignored patterns or specific ones.
 
 [![ignore-patterns](/uploads/article/019f8a80-cc67-73be-b359-c0cc3c3adbed/ignore-patterns.png)](/uploads/2013/04/ignore-patterns.png)
 
diff --git a/public/md-articles/php-development/welcome-to-the-10th-zend-certified-engineer-in-dotboost-team.md b/public/md-articles/php-development/welcome-to-the-10th-zend-certified-engineer-in-dotboost-team.md
index dfe9e2d2..71b449db 100644
--- a/public/md-articles/php-development/welcome-to-the-10th-zend-certified-engineer-in-dotboost-team.md
+++ b/public/md-articles/php-development/welcome-to-the-10th-zend-certified-engineer-in-dotboost-team.md
@@ -11,16 +11,19 @@ language: "en"
 # Welcome to the 10th Zend Certified Engineer in Dotboost Team
 
 ## TL;DR
+
 Dotboost Technologies Inc. announces that the 10th member of its team has passed the Zend Certified Engineer exam, part of its commitment to top-level PHP development and quality assurance for clients.
 Next up: adopting Zend Framework 2 best practices, pursuing the Zend Framework 2 Certified Architect exam, and, starting in 2014, making Zend Certification mandatory for every developer on the team.
 
-Today is a major milestone for our [Dotboost Technologies Inc.](http://www.dotboost.com) Company. We are announcing the 10th member of the team passed the Zend Certified Engineer exam.
-
-[Zend Yellow Pages](http://bit.ly/dotboost-zce)
+## Milestone Announcement
 
-This is part of our commitment to ensure that our clients have access to top level PHP development as standard practice and allows us to follow a strong quality assurance program. The next step is to implement the Zend Framework 2 best practices and to take the upcoming Zend Framework 2 Certified Architect exam.
+Today is a major milestone for [Dotboost Technologies Inc.](http://www.dotboost.com)
+The company is announcing that the 10th member of the team has passed the Zend Certified Engineer exam.
+See the [Zend Yellow Pages](http://bit.ly/dotboost-zce) listing.
 
-Beginning 2014, a Zend Certification will became mandatory for every developer in our team.
+This is part of the company's commitment to ensure that clients have access to top level PHP development as standard practice, and it allows the team to follow a strong quality assurance program.
+The next step is to implement Zend Framework 2 best practices and to take the upcoming Zend Framework 2 Certified Architect exam.
+Beginning 2014, a Zend Certification will become mandatory for every developer in the team.
 
 ## FAQ
 
diff --git a/public/md-articles/php-development/zend-server-5-5-quick-setup-on-windows.md b/public/md-articles/php-development/zend-server-5-5-quick-setup-on-windows.md
index 68aaec3d..aced37fb 100644
--- a/public/md-articles/php-development/zend-server-5-5-quick-setup-on-windows.md
+++ b/public/md-articles/php-development/zend-server-5-5-quick-setup-on-windows.md
@@ -11,37 +11,26 @@ language: "en"
 # Zend Server 5.5 Quick Setup on Windows
 
 ## TL;DR
-A fresh Zend Server 5.5.0 install on Windows 7 needs a few quick tweaks before it's ready for development: enabling mod_rewrite in Apache, adjusting a handful of PHP directives, and fixing APC so it actually works even though it's shown as enabled.
-
-In order to make  usable a fresh installation of Zend Server 5.5.0 on Windows 7, and be ready for development , few quick steps are required:
-
-**1. Enable mod_rewrite**
-
--  Open the file ZEND_INSTALATION_PATH/Apache2/conf/httpd.conf. Change the directive *AllowOverride* fron None to All
-
-- Restart Apache service
-
-**2. PHP fine tunes**
-
-- go to Zend Server administration interface, [http://localhost:10081/ZendServer/](http://localhost:10081/ZendServer/), Server Setup-> Directives, and change the following:
-
-- set timezone:  set ***date*** to *America/New_York*
 
--set error reporting: **display_errors ** set to **on**, and **error_reporting** to **-1** .
-
-**3. Enable APC**
-
-- APC is listed as been enabled in Zend Server admin interface, but the app dll file is missing, and APC is not working
-
-- download the latest php apc dll file, from [here](http://windows.php.net/downloads/pecl/releases/apc/) . Quite old file at the time of this post, *php_apc-3.1.5-5.3-nts-vc9-x86.zip*, which is the latest Non-thread-safe VC9 file available. Download the archive and extract the file *php_apc.dll* to ZEND_INSTALATION_PATH/ZendServer/lib/phpext/
-
-- open *php.ini* file, from ZEND_INSTALATION_PATH/ZendServer\etc\php.ini , add the line *extension=php_apc.dll*
-
-- Restart Apache service
-
- 
+A fresh Zend Server 5.5.0 install on Windows 7 needs a few quick tweaks before it's ready for development: enabling mod_rewrite in Apache, adjusting a handful of PHP directives, and fixing APC so it actually works even though it's shown as enabled.
 
- 
+## Quick Setup Steps
+
+In order to make a fresh installation of Zend Server 5.5.0 on Windows 7 usable and ready for development, a few quick steps are required.
+
+1. Enable mod_rewrite.
+   - Open the file ZEND_INSTALATION_PATH/Apache2/conf/httpd.conf and change the AllowOverride directive from None to All.
+   - Restart the Apache service.
+2. PHP fine tunes.
+   - Go to the Zend Server administration interface at [http://localhost:10081/ZendServer/](http://localhost:10081/ZendServer/), then Server Setup -> Directives, and change the following.
+   - Set timezone: set date to America/New_York.
+   - Set error reporting: display_errors to on, and error_reporting to -1.
+3. Enable APC.
+   - APC is listed as enabled in the Zend Server admin interface, but the app dll file is missing, so APC isn't actually working.
+   - Download the latest php_apc dll file from [here](http://windows.php.net/downloads/pecl/releases/apc/) - at the time of writing, php_apc-3.1.5-5.3-nts-vc9-x86.zip was the latest non-thread-safe VC9 build available.
+   - Extract php_apc.dll to ZEND_INSTALATION_PATH/ZendServer/lib/phpext/.
+   - Open the php.ini file from ZEND_INSTALATION_PATH/ZendServer/etc/php.ini and add the line extension=php_apc.dll.
+   - Restart the Apache service.
 
 ## FAQ
 
diff --git a/public/md-articles/php-troubleshooting/fix-installing-pear-packages-with-php-7-2.md b/public/md-articles/php-troubleshooting/fix-installing-pear-packages-with-php-7-2.md
index e76b0fdc..eefef505 100644
--- a/public/md-articles/php-troubleshooting/fix-installing-pear-packages-with-php-7-2.md
+++ b/public/md-articles/php-troubleshooting/fix-installing-pear-packages-with-php-7-2.md
@@ -11,20 +11,19 @@ language: "en"
 # FIX: Installing PEAR packages with PHP 7.2
 
 ## TL;DR
+
 On PHP 7.2, installing PEAR packages such as PHP Code Sniffer fails with a "Cannot use result of built-in function in write context" error in Archive_Tar's Tar.php, because a function is called by reference.
 The fix is to edit the offending line in Tar.php to drop the by-reference call, then reinstall Archive_Tar and the target package.
 
-This article will cover the solution to the PEAR "*Cannot use result of built-in function in write context*" issue.
-
 ## The Issue
 
 If installing a pear package (for instance PHP Code Sniffer), when running:
 
-```
+```bash
 pear install PHP_CodeSniffer
 ```
 
-This error is shown
+this error is shown:
 
 ```
 PHP Fatal error: Cannot use result of built-in function in write context in ...\php\pear\Archive\Tar.php on line 639
@@ -32,61 +31,47 @@ Fatal error: Cannot use result of built-in function in write context in ...\pear
 ```
 
 This error is shown because the function is called by reference.
-
 More details about this issue can be found in [this Pull Request](https://github.com/pear/Archive_Tar/pull/18).
 
- 
-
-## The solution
+## The Solution
 
-You might be tempted to execute the following
+You might be tempted to execute the following:
 
-```
+```bash
 pear install Archive_Tar
 ```
 
 which will result in the same error.
-
- 
-
 Go to the line indicated in the error (639 in this case) and replace:
 
-```
- $v_att_list = & func_get_args();
+```php
+$v_att_list = &func_get_args();
 ```
 
-with
+with:
 
+```php
+$v_att_list = func_get_args();
 ```
- $v_att_list = func_get_args();
-```
-
-The above means the **func_get_args() **isn't called by reference anymore.
 
-## Our recommendation
+The above means func_get_args() isn't called by reference anymore.
 
-The above does fix the problem, **but we recommend installing **the Archive_Tar again so you have the latest working version.
-
- 
+## Our Recommendation
 
+The above does fix the problem, but it's recommended to also install Archive_Tar again so you have the latest working version.
 Run the following command:
 
-```
+```bash
 pear install Archive_Tar
 ```
 
-This will update your Archive Tar PEAR package.
+This will update your Archive_Tar PEAR package.
+And to install the code sniffer, run:
 
- 
-
-And to install the code sniffer run:
-
-```
+```bash
 pear install PHP_CodeSniffer
 ```
 
- 
-
 ## FAQ
 
 **Q: What error occurs when installing PEAR packages with PHP 7.2?**
diff --git a/public/md-articles/php-troubleshooting/where-is-the-intl-php-extension-problem-solved.md b/public/md-articles/php-troubleshooting/where-is-the-intl-php-extension-problem-solved.md
index 0f44ce5d..00907b85 100644
--- a/public/md-articles/php-troubleshooting/where-is-the-intl-php-extension-problem-solved.md
+++ b/public/md-articles/php-troubleshooting/where-is-the-intl-php-extension-problem-solved.md
@@ -11,29 +11,26 @@ language: "en"
 # Where is the intl PHP extension? Problem solved!
 
 ## TL;DR
+
 Errors like "requires intl PHP extension" or "extension intl is missing" happen because the PHP Intl extension isn't installed or enabled.
 This article explains what Intl is used for, why it might be missing depending on whether you have a bundled or unbundled PHP install, and gives step-by-step fixes for both Linux and Windows servers.
 
 ## Problem
 
-PHP packages/frameworks/libraries/scripts we work with might require different PHP extensions. In this case the Intl extension is needed to work with using Internationalization Functions.
-
-[What is Internationalization?](https://www.w3.org/International/questions/qa-i18n)
-
-Got any of these error messages?
+PHP packages, frameworks, libraries, and scripts might require different PHP extensions.
+In this case, the Intl extension is needed to work with Internationalization Functions.
+See [What is Internationalization?](https://www.w3.org/International/questions/qa-i18n) for background.
+Have you seen any of these error messages?
 
 - Zend InputFilter requires intl PHP extension
 - The requested PHP extension intl is missing from your system
 
- 
-
 This happened because the PHP Intl extension isn't installed or enabled.
+Parts of this tutorial can also serve as a guide for installing or enabling other extensions.
 
-Parts of this tutorial can be also a guide for installing or enabling other extensions.
-
-## What is PHP Intl?
+## What Is PHP Intl?
 
-> Internationalization extension (further is referred as Intl) is a wrapper for » ICU library, enabling PHP programmers to perform various locale-aware operations including but not limited to formatting, transliteration, encoding conversion, calendar operations
+> Internationalization extension (further referred to as Intl) is a wrapper for the ICU library, enabling PHP programmers to perform various locale-aware operations including but not limited to formatting, transliteration, encoding conversion, and calendar operations.
 
 Source: [PHP Documentation](https://www.php.net/manual/en/book.intl.php)
 
@@ -43,58 +40,47 @@ Source: [PHP Documentation](http://php.net/manual/en/intl.installation.php)
 
 ## Cause
 
-If you have installed the unbundled PHP version, the extension is not installed on the system. (unless you've installed it separately)
-
-If you have the bundled PHP version, the extension might be existing but not enabled.
-
- 
+If you have installed the unbundled PHP version, the extension is not installed on the system, unless you've installed it separately.
+If you have the bundled PHP version, the extension might exist but not be enabled.
 
 ## Solutions
 
-### For Linux-based Server (assuming you have root access):
-
-- Make sure the **php_intl.so** file exists within your php extensions directory, find the extensions directory by:
-  - using **phpinfo()**
-  - running this command: `php -r "echo ini_get('extension_dir');"`
-  - (note: both options gets the extension_dir right from the PHP runtime configuration)
+### For Linux-Based Server (Assuming You Have Root Access)
 
+- Make sure the php_intl.so file exists within your PHP extensions directory.
+Find the extensions directory by using `phpinfo()`, or by running: `php -r "echo ini_get('extension_dir');"` - both options get the extension_dir right from the PHP runtime configuration.
 - If the file exists:
-  - search for the config file (**php.ini,** usually **/etc/php.ini**) and open it
-  - Make sure the line "extension=php_intl.so" is existing and not commented
-  - Restart the web server (usually **sudo service httpd restart**)
-  - Check if the extension is enabled using **phpinfo()**
-- If the file doesn't exist
-  - Check your php version by running the "php -v" command
-  - For PHP 5 install the **php-intl** package using your package manager - [package managers and commands](https://en.wikipedia.org/wiki/Package_manager#Front-ends_for_locally_compiled_packages)
-    - Most common: **apt-get install php-intl (for ubuntu-based linux) **or **yum install php-intl (for CentOS)**
-  - For PHP 7, install the **php7.x-intl **(depending on your php version)
-  - Repeat the steps for the case in which the file exists
-
-For projects hosted on a shared hosting platform you must ask your hosting provider to install/enable the PHP Intl extension.
-
- 
+  - Search for the config file (php.ini, usually /etc/php.ini) and open it.
+  - Make sure the line "extension=php_intl.so" exists and is not commented out.
+  - Restart the web server (usually `sudo service httpd restart`).
+  - Check if the extension is enabled using `phpinfo()`.
+- If the file doesn't exist:
+  - Check your PHP version by running the `php -v` command.
+  - For PHP 5, install the php-intl package using your [package manager](https://en.wikipedia.org/wiki/Package_manager#Front-ends_for_locally_compiled_packages) - most commonly `apt-get install php-intl` (Ubuntu-based) or `yum install php-intl` (CentOS).
+  - For PHP 7, install the php7.x-intl package (depending on your PHP version).
+  - Repeat the steps for the case in which the file exists.
 
-### For Windows-based Server:
+For projects hosted on a shared hosting platform, you must ask your hosting provider to install/enable the PHP Intl extension.
 
-- Make sure the **php_intl.dll** file exists within your php extensions directory
-  - for separately installed PHP: C:\path\to\php\ext\
-  - for xampp: C:\path\to\xampp\php\ext
-  - (note: your drive letter might be different)
+### For Windows-Based Server
 
+- Make sure the php_intl.dll file exists within your PHP extensions directory:
+  - For a separately installed PHP: C:\path\to\php\ext\
+  - For XAMPP: C:\path\to\xampp\php\ext
+  - Note: your drive letter might be different.
 - If the file exists:
-  - search for the config file (**php.ini,** usually in the same folder as the php executable) and open it
-  - Make sure the line "extension=php_intl.dll" is existing and not commented
-  - Restart the web server (usually apache)
-  - Check if the extension is enabled using **phpinfo()**
-
+  - Search for the config file (php.ini, usually in the same folder as the PHP executable) and open it.
+  - Make sure the line "extension=php_intl.dll" exists and is not commented out.
+  - Restart the web server (usually Apache).
+  - Check if the extension is enabled using `phpinfo()`.
 - If the file doesn't exist:
-  - Check your php version by running the "php -v" command
-  - Download the PHP version that corresponds to yours from the [PHP Downloads Page](http://windows.php.net/download/) (TS/NTS, x86/x64)
-    - To find thread safety for php, run: **php -i | findstr "Thread"** , [source & more info](http://stackoverflow.com/questions/5799843/find-if-the-installed-php-is-threadsafe-or-nonthreadsafe%20target=).
-  - Search for the **php_intl.dll** file in the ext folder in that version and copy it in your php\ext folder
-  - Repeat the steps for the case in which the file exists
+  - Check your PHP version by running the `php -v` command.
+  - Download the PHP version that corresponds to yours from the [PHP Downloads Page](http://windows.php.net/download/) (TS/NTS, x86/x64).
+To find thread safety for your PHP, run `php -i | findstr "Thread"`.
+  - Search for the php_intl.dll file in the ext folder of that downloaded version and copy it into your php\ext folder.
+  - Repeat the steps for the case in which the file exists.
 
-Edit: changed **php7.0 **occurrences with **php7.x** as the version may vary.
+Edit: changed php7.0 occurrences with php7.x, as the version may vary.
 
 ## FAQ
 
diff --git a/public/md-articles/phpstorm/code-quality-how-to-setup-phpcs-in-phpstorm.md b/public/md-articles/phpstorm/code-quality-how-to-setup-phpcs-in-phpstorm.md
index 12773335..3e31b3df 100644
--- a/public/md-articles/phpstorm/code-quality-how-to-setup-phpcs-in-phpstorm.md
+++ b/public/md-articles/phpstorm/code-quality-how-to-setup-phpcs-in-phpstorm.md
@@ -11,75 +11,49 @@ language: "en"
 # Code Quality: How to setup phpcs in PHPStorm
 
 ## TL;DR
+
 PHP_CodeSniffer (phpcs) needs to be configured correctly in PHPStorm under PHP > Quality Tools > PHP_CodeSniffer, with the Custom coding standard pointed at your project's phpcs.xml file.
 This article gives separate setup steps for a freshly cloned project versus an existing one that isn't reporting issues yet, and explains how to read the resulting inline error and warning indicators in the editor.
 
-PHP_CodeSniffer or phpcs is a tool that helps developers maintain a specific standard in the way they write code. In order to be able to provide relevant information, phpcs needs to be configured correctly in PHPStorm (see image).
+PHP_CodeSniffer or phpcs is a tool that helps developers maintain a specific standard in the way they write code.
+In order to be able to provide relevant information, phpcs needs to be configured correctly in PHPStorm (see image).
 
 ![](/uploads/article/019f8a80-cc90-7160-853d-18cb7411b9ff/image.png)
 
 Whether you just cloned or you are already working on a project, follow the below guide on how to prepare your environment.
 
-## When cloning a project
-
-**Step 1**:
-
-*Windows Terminal*: Move to the directory where you want to clone the project
-
-**Step 2**:
-
-*Windows Terminal*: Clone the project
-
-**Step 3**:
-
-*PHPStorm*: install composer dependencies
-
-**Step 4**:
-
-*PHPStorm*: restart
-
-**Step 5**:
-
-*PHPStorm*: Open Settings (*FIle* -> *Settings*) and go to *PHP* -> *Quality Tools* -> *PHP_CodeSniffer*:
-
-- Make sure that the inspection button is ON
-- *Coding standard* is set to *Custom* and the field next to it contains the path to your project's *phpcs.xml* file
-
-## For an existing project
-
-**Step 1**:
-
-*PHPStorm*: Open Settings (*FIle* -> *Settings*) and go to *PHP* -> *Quality Tools* -> *PHP_CodeSniffer*. There, if *Coding standard* is set to *Custom* and the field next to it contains the path to your project's *phpcs.xml* file, then PHPStorm is configured correctly to use phpcs - NO need to continue with the next steps.
-
-**Step 2**:
-
-*PHPStorm*: delete (if exists) the vendor directory
-
-**Step 3**:
-
-*PHPStorm*: install composer dependencies
-
-**Step 4**:
+## When Cloning a Project
 
-*PHPStorm*: restart
+1. Windows Terminal: Move to the directory where you want to clone the project.
+2. Windows Terminal: Clone the project.
+3. PHPStorm: install composer dependencies.
+4. PHPStorm: restart.
+5. PHPStorm: Open Settings (File -> Settings) and go to PHP -> Quality Tools -> PHP_CodeSniffer:
+    - Make sure that the inspection button is ON.
+    - Coding standard is set to Custom and the field next to it contains the path to your project's phpcs.xml file.
 
-**Step 5**:
+## For an Existing Project
 
-Go to **Step 1**.
+1. PHPStorm: Open Settings (File -> Settings) and go to PHP -> Quality Tools -> PHP_CodeSniffer.
+There, if Coding standard is set to Custom and the field next to it contains the path to your project's phpcs.xml file, then PHPStorm is configured correctly to use phpcs - NO need to continue with the next steps.
+2. PHPStorm: delete (if exists) the vendor directory.
+3. PHPStorm: install composer dependencies.
+4. PHPStorm: restart.
+5. Go to Step 1.
 
 After you have the above configurations, you should start seeing information in the top-right corner of the editor.
 
 ![](/uploads/article/019f8a80-cc90-7160-853d-18cb7411b9ff/image-1-1024x83.png)
 
-Once the PHPStorm has finished analyzing the opened file, you should see either a green tick (meaning no errors)
+Once PHPStorm has finished analyzing the opened file, you should see either a green tick (meaning no errors)
 
 ![](/uploads/article/019f8a80-cc90-7160-853d-18cb7411b9ff/image-2-1024x66.png)
 
-or a count of all the errors, warnings, typos:
+or a count of all the errors, warnings, and typos.
 
 ![](/uploads/article/019f8a80-cc90-7160-853d-18cb7411b9ff/image-3.png)
 
-Clicking on them will open a section where you get detailed information on each item, their location and recommendations on how to fix them:
+Clicking on them will open a section where you get detailed information on each item, their location, and recommendations on how to fix them.
 
 ![](/uploads/article/019f8a80-cc90-7160-853d-18cb7411b9ff/image-5.png)
 
diff --git a/public/md-articles/zend-framework/scienta-zf-debug-bar-a-very-helpfull-zf-debug-tool.md b/public/md-articles/zend-framework/scienta-zf-debug-bar-a-very-helpfull-zf-debug-tool.md
index 3c1509e0..80487470 100644
--- a/public/md-articles/zend-framework/scienta-zf-debug-bar-a-very-helpfull-zf-debug-tool.md
+++ b/public/md-articles/zend-framework/scienta-zf-debug-bar-a-very-helpfull-zf-debug-tool.md
@@ -11,15 +11,15 @@ language: "en"
 # Scienta ZF Debug Bar: A very helpfull ZF debug tool
 
 ## TL;DR
+
 The author came across the Scienta ZF Debug Bar, a debugging tool for Zend Framework applications.
 Dotkernel had been relying on its own basic debug bar, which only showed queries, time spent, and memory used.
 Finding Scienta far more complex and polished than their internal tool, the Dotkernel team decided to switch to it and integrate it into the Dotkernel code base.
 
-Just found today a very interesting and helpful debug tool:
-
-**[Scienta](http://jokke.dk/software/scientadebugbar)**
+Just found today a very interesting and helpful debug tool: [Scienta](http://jokke.dk/software/scientadebugbar).
 
-We at Dotkernel used some very basic debug bar:  queries, time spent , memory used.  But this **Scienta** is way more complex and nicer then our internal code,  so we switch to it and integrate it in Dotkernel code base.
+We at Dotkernel used some very basic debug bar: queries, time spent, memory used.
+But this Scienta is way more complex and nicer than our internal code, so we switch to it and integrate it in Dotkernel code base.
 
 ## FAQ
 
diff --git a/public/md-articles/zend-framework/sunsetting-pear-channel-for-zend-framework-1.md b/public/md-articles/zend-framework/sunsetting-pear-channel-for-zend-framework-1.md
index fe3ed7e6..d5cdd1e8 100644
--- a/public/md-articles/zend-framework/sunsetting-pear-channel-for-zend-framework-1.md
+++ b/public/md-articles/zend-framework/sunsetting-pear-channel-for-zend-framework-1.md
@@ -11,19 +11,18 @@ language: "en"
 # Sunsetting PEAR Channel for Zend Framework 1
 
 ## TL;DR
+
 Dotkernel is sunsetting its unofficial PEAR channel for Zend Framework 1, which was created in 2016 when PEAR was still widely used.
 The main reasons are that upgrading PEAR to work with PHP 8 is too painful, and the channel currently runs on an LXC container with CentOS 7, which doesn't work on the latest Proxmox version, making the upgrade to AlmaLinux not worth the effort.
 The post closes by thanking PEAR for its historical contribution to the PHP ecosystem.
 
-## Sunsetting PEAR Channel for Zend Framework 1
-
-The unofficial **PEAR channel for Zend Framework 1** was created in [2016](https://www.dotkernel.com/dotkernel/migration-of-zend-framework-1-pear-channel/) , at the time when [PEAR](https://pear.php.net/) was still used a lot.
+The unofficial PEAR channel for Zend Framework 1 was created in [2016](https://www.dotkernel.com/dotkernel/migration-of-zend-framework-1-pear-channel/), at the time when [PEAR](https://pear.php.net/) was still used a lot.
 
-Due to the fact that is a pain to upgrade **PEAR** to work with **PHP 8** , we must sunset the channel .
+Due to the fact that it is a pain to upgrade PEAR to work with PHP 8, we must sunset the channel.
 
-Another reason for sunsetting is that currently is running on an LXC container with Centos 7 , which does not work on latest Proxmox version, and the upgrade to Amlaminux is too much of a pain.
+Another reason for sunsetting is that it currently runs on an LXC container with CentOS 7, which does not work on the latest Proxmox version, and the upgrade to AlmaLinux is too much of a pain.
 
-Thank you PEAR for your contribution to PHP ecosystem, it was a major part of **PHP** infrastructure .
+Thank you PEAR for your contribution to the PHP ecosystem, it was a major part of PHP infrastructure.
 
 ## FAQ
 
diff --git a/public/md-articles/zend-framework/wurfl-php-api-libraries-gpl-versions.md b/public/md-articles/zend-framework/wurfl-php-api-libraries-gpl-versions.md
index 3886fb71..c5926497 100644
--- a/public/md-articles/zend-framework/wurfl-php-api-libraries-gpl-versions.md
+++ b/public/md-articles/zend-framework/wurfl-php-api-libraries-gpl-versions.md
@@ -11,19 +11,18 @@ language: "en"
 # WURFL PHP API libraries , GPL versions
 
 ## TL;DR
+
 GPL versions of the WURFL PHP API libraries were made available: version 1.1, the one integrated into Zend Framework's Zend_Http_UserAgent component, and version 1.2.1, the latest released under the GPL license.
 A later edit notes the download was removed because an AGPL version is available (which readers need to get themselves), and as a favor to Luca Passani.
 
-GPL versions of WURFL PHP API libraries are ready to be downloaded from here .
+GPL versions of WURFL PHP API libraries are ready to be downloaded from here.
 
-Version 1.1 is the one integrated in Zend Framework Zend_Htpp_UserAgent component.
+Version 1.1 is the one integrated in Zend Framework Zend_Http_UserAgent component.
 
 Version 1.2.1 is the latest released under GPL license.
 
 *Later Edit: removed because A) AGPL version is available, but you'll need to download it for yourself and B) removed to make Luca Passani a favor :-).*
 
- 
-
 ## FAQ
 
 **Q: Which WURFL PHP API library versions were made available under GPL?**
diff --git a/public/md-articles/zend-framework/zend-framework-1-12-4-released-with-security-fixes.md b/public/md-articles/zend-framework/zend-framework-1-12-4-released-with-security-fixes.md
index 93fefd43..139749c6 100644
--- a/public/md-articles/zend-framework/zend-framework-1-12-4-released-with-security-fixes.md
+++ b/public/md-articles/zend-framework/zend-framework-1-12-4-released-with-security-fixes.md
@@ -11,25 +11,24 @@ language: "en"
 # Zend Framework 1.12.4 Released with Security Fixes
 
 ## TL;DR
+
 Matthew Weier O'Phinney announced the release of Zend Framework 1.12.4, along with 2.1.6 and 2.2.6, all containing security updates, and the ZF PEAR channel was updated to the latest 1.12.4 release.
 A March 7, 2014 edit notes that Zend Framework 1.12.5 was subsequently released to fix a backward compatibility issue introduced in the 1.12.4 release.
 
-[Matthew Weier O'Phinney](http://mwop.net/) just announced the release of ZF 1.12.4, 2.1.6, and 2.2.6 m with Security Updates
+[Matthew Weier O'Phinney](http://mwop.net/) just announced the release of ZF 1.12.4, 2.1.6, and 2.2.6 with Security Updates.
 
 For more information, please read the official release announcement: [Zend Framework Released](http://framework.zend.com/blog/zend-framework-1-12-4-2-1-6-and-2-2-6-released.html)
 
-Also, the ZF  PEAR channel was updated to latest 1.12.4 release.
+Also, the ZF PEAR channel was updated to latest 1.12.4 release.
 
 [pear upgrade zend/zend](http://code.google.com/p/zend/)
 
-**March 7, 2014 EDIT:**
+March 7, 2014 EDIT:
 
 Zend Framework 1.12.5 was released, in order to fix a backward compatibility issue introduced in 1.12.4 release.
 
 [Release Announcement](http://framework.zend.com/blog/zend-framework-1-12-5-released.html)
 
- 
-
 ## FAQ
 
 **Q: Who announced the release of Zend Framework 1.12.4, and what other versions were released alongside it?**
diff --git a/public/md-articles/zend-framework/zend-framework-1-7-0-released.md b/public/md-articles/zend-framework/zend-framework-1-7-0-released.md
index 99f13a9d..029f9b39 100644
--- a/public/md-articles/zend-framework/zend-framework-1-7-0-released.md
+++ b/public/md-articles/zend-framework/zend-framework-1-7-0-released.md
@@ -11,14 +11,13 @@ language: "en"
 # Zend Framework 1.7.0 Released
 
 ## TL;DR
+
 Zend Framework 1.7.0 has been released, and its headline feature is support for Adobe's Action Message Format (AMF) protocol in PHP 5 applications.
 The release is available directly from the official Zend Framework download page.
 
-At first glance , the biggest news is AMF support:
-
-[Adobe's Action Message Format protocol to your PHP 5 application](http://framework.zend.com/manual/1.12/en/zend.amf.server.html)
-
-[Download latest  ZF](http://framework.zend.com/download/latest)
+At first glance, the biggest news is AMF support.
+This brings [Adobe's Action Message Format protocol to your PHP 5 application](http://framework.zend.com/manual/1.12/en/zend.amf.server.html).
+You can [download the latest ZF](http://framework.zend.com/download/latest) release directly.
 
 ## FAQ
 
diff --git a/public/md-articles/zend-framework/zend-framework-1-end-of-life.md b/public/md-articles/zend-framework/zend-framework-1-end-of-life.md
index f12ac98a..c0ef2b4b 100644
--- a/public/md-articles/zend-framework/zend-framework-1-end-of-life.md
+++ b/public/md-articles/zend-framework/zend-framework-1-end-of-life.md
@@ -11,13 +11,28 @@ language: "en"
 # Zend Framework 1 End-of-Life
 
 ## TL;DR
+
 Zend Framework 1 has officially entered End-of-Life (EOL) status now that Zend Framework 3 has been released.
 Security updates for Zend Framework 1 continued only until 28 September 2016, three months after the announcement.
 
-EOL (End-of-Life) term was just announced.
+The End-of-Life (EOL) term was just announced.
+Only up until Sept. 28, 2016, will Zend Framework 1 receive security updates.
+
+"With the release of Zend Framework 3, it's time to halt development on Zend Framework 1.
+As such, we hereby announce that Zend Framework 1 reaches its End of Life (EOL) three months from today, on 28 September 2016."
+
+Read the [official announcement](https://framework.zend.com/blog/2016-06-28-zf1-eol.html).
+
+## FAQ
+
+**Q: What does EOL mean for Zend Framework 1?**
+A: EOL stands for End-of-Life, meaning Zend Framework 1 has reached the end of its official support and development lifecycle.
 
-Only up until Sept. 28, 2016, Zend Framework 1 will receive security updates.
+**Q: Until when did Zend Framework 1 keep receiving security updates?**
+A: Only up until 28 September 2016, three months after the EOL announcement was made.
 
-"With the release of Zend Framework 3, it's time to halt development on Zend Framework 1. As such, we hereby announce that Zend Framework 1 reaches its End of Life (EOL) three months from today, on 28 September 2016."
+**Q: Why was Zend Framework 1 being discontinued?**
+A: Because Zend Framework 3 had been released, and it was time to halt development on Zend Framework 1.
 
-Read the official [announcement](https://framework.zend.com/blog/2016-06-28-zf1-eol.html).
+**Q: Where was this announced?**
+A: In an official Zend Framework blog post announcing that Zend Framework 1 reaches its End of Life (EOL) on 28 September 2016.
diff --git a/public/md-articles/zend-framework/zend-framework-as-pear-accessible-repository-on-plesk-server.md b/public/md-articles/zend-framework/zend-framework-as-pear-accessible-repository-on-plesk-server.md
index 5870e2bf..d436ccb0 100644
--- a/public/md-articles/zend-framework/zend-framework-as-pear-accessible-repository-on-plesk-server.md
+++ b/public/md-articles/zend-framework/zend-framework-as-pear-accessible-repository-on-plesk-server.md
@@ -11,17 +11,48 @@ language: "en"
 # Zend Framework as PEAR accessible repository on Plesk server
 
 ## TL;DR
+
 Rather than copying all of Zend Framework's many files into every project, this article shows how to install ZF as a PEAR-accessible repository on a Plesk server.
 This makes it easier to track which ZF version is installed on which server and avoids manually updating each project, though it can introduce backward compatibility concerns in future ZF releases.
 
-Why we want to install ZF as PEAR ? Because is too boring and time consuming to move all ZF files up and down for each script you want to install , there are a lot of files.
+Why we want to install ZF as PEAR?
+Because it's too boring and time consuming to move all ZF files up and down for each script you want to install, and there are a lot of files.
+
+Also that way we can forget about the need to update ZF at latest versions, and keep track of which version and on which server we have ZF.
+Of course, backward compatibility can be an issue in future ZF releases (like the 2.0 branch for PHP > 5.3).
+
+1. Install PEAR if it is not installed already.
+2. Follow the instructions for [ZF PEAR](http://code.google.com/p/zend/).
+Then simply use: `pear install zend/zend`
+3. Create a vhosts.conf file in /var/www/vhosts/dotkernel.com/conf or wherever your vhost configuration folder is located.
+4. In that file, remove the open_basedir:
 
-Also that way we can forget about the need to update ZF at latest versions, and keep tracks of which version and on which server we have ZF.  Of course, backward compatibility  can be an issue in future ZF releases ( like 2.0 branch for PHP > 5.3)
+```ini
+>php_admin_value open_basedir "/var/www/vhosts/dotkernel.com/httpdocs:/tmp:/usr/share/pear"
+```
 
-1. Install PEAR if is not installed  already .
-2. Follow the instructions for [ZF PEAR](http://code.google.com/p/zend/). Then simply use: *pear install zend/zend*
-3. Create a vhosts.conf file in /var/www/vhosts/dotkernel.com/conf  or where is your vhost configuration folder located.
-4. In that file, remove the open_basedir :
-5. rebuild all vhosts:  /usr/local/psa/admin/sbin/websrvmng -a
+5. Rebuild all vhosts: /usr/local/psa/admin/sbin/websrvmng -a
 6. Restart httpd
-7. Call directly the preloader: require_once 'Zend/Loader/Autoloader.php';
+7. Call directly the preloader:
+
+```php
+> require_once 'Zend/Loader/Autoloader.php';
+```
+
+## FAQ
+
+**Q: Why install Zend Framework as a PEAR-accessible repository?**
+A: Because manually moving all ZF files up and down for each script you want to install is boring and time consuming, given the large number of files involved.
+It also lets you avoid manually updating ZF to the latest version in every project, and keep track of which version is installed on which server.
+
+**Q: What is a potential downside of this approach?**
+A: Backward compatibility can be an issue in future ZF releases, such as the 2.0 branch built for PHP > 5.3.
+
+**Q: What is the first step to set this up?**
+A: Install PEAR if it isn't installed already, then follow the instructions for ZF PEAR and run `pear install zend/zend`.
+
+**Q: What needs to change in the vhosts configuration?**
+A: Create a vhosts.conf file in your vhost configuration folder (e.g. /var/www/vhosts/dotkernel.com/conf), remove the open_basedir restriction, rebuild all vhosts with websrvmng -a, and restart httpd.
+
+**Q: How do you load Zend Framework classes after this setup?**
+A: By calling the preloader directly, e.g. `require_once 'Zend/Loader/Autoloader.php';`
diff --git a/public/md-articles/zend-framework/zend-mail-and-zend-http-security-fixes-in-zend-framework-1-12-12.md b/public/md-articles/zend-framework/zend-mail-and-zend-http-security-fixes-in-zend-framework-1-12-12.md
index e8d8532f..48a41320 100644
--- a/public/md-articles/zend-framework/zend-mail-and-zend-http-security-fixes-in-zend-framework-1-12-12.md
+++ b/public/md-articles/zend-framework/zend-mail-and-zend-http-security-fixes-in-zend-framework-1-12-12.md
@@ -11,24 +11,41 @@ language: "en"
 # Zend_Mail and Zend_Http Security Fixes in Zend Framework 1.12.12
 
 ## TL;DR
+
 Zend Framework 1.12.12 was released with security fixes for the Zend_Mail and Zend_Http components.
 Consumers of these components, including Dotkernel which relies heavily on Zend_Mail, were strongly urged to upgrade immediately via PEAR or by applying the patch directly.
 A follow-up release, 1.12.13, was issued shortly after to fix a regression introduced in 1.12.12.
 
-The release of ZF 1.12.12 was just announced, with Security Updates especially on Zend_Mail and Zend_Http components.
+The release of ZF 1.12.12 was just announced, with security updates especially on the Zend_Mail and Zend_Http components.
+For more information, please read the official release announcement: [Zend Framework 1.12.12 Released](http://bit.ly/1Hr0K6e).
+
+Also, the ZF PEAR channel was updated to the latest 1.12.12 release.
+
+pear upgrade zend/zend
+
+We strongly recommend that consumers of the Zend_Http and Zend_Mail components upgrade immediately.
+Also, Dotkernel Application Framework uses the Zend_Mail component intensively.
+
+If you cannot, you can download the patch separately and apply it to your ZF install: [ZF2015-04 patch for ZF1](https://packages.zendframework.com/releases/ZendFramework-1.12.12/0001-ZF2015-04-Fix-CRLF-injections-in-HTTP-and-Mail.patch).
 
-For more information, please read the official release announcement: [Zend Framework 1.12.12 Released](http://bit.ly/1Hr0K6e)
+May 20, 2015 EDIT:
 
-Also, the ZF PEAR channel was updated to latest 1.12.12 release.
+Zend Framework 1.12.13 was released, in order to fix a regression issue introduced in the 1.12.12 release.
+See the [Release Announcement](http://framework.zend.com/blog/zend-framework-1-12-13-released.html).
 
-**pear upgrade zend/zend**
+## FAQ
 
-We strongly recommend that consumers of the Zend_Http and Zend_Mail components upgrade immediately. Also, Dotkernel Application Framework use intensively the Zend_Mail component.
+**Q: What security issue did Zend Framework 1.12.12 address?**
+A: It fixed security issues in the Zend_Mail and Zend_Http components.
 
-If you cannot, you can download the patch separately and apply it to your ZF install: [ZF2015-04 patch for ZF1](https://packages.zendframework.com/releases/ZendFramework-1.12.12/0001-ZF2015-04-Fix-CRLF-injections-in-HTTP-and-Mail.patch)
+**Q: How can you get the fixed version?**
+A: By upgrading via the ZF PEAR channel using `pear upgrade zend/zend`, or by downloading and applying the ZF2015-04 patch separately if you cannot upgrade.
 
-**May 20, 2015 EDIT:**
+**Q: Why was this update particularly important for Dotkernel users?**
+A: Because Dotkernel Application Framework uses the Zend_Mail component intensively, consumers of Zend_Http and Zend_Mail were strongly urged to upgrade immediately.
 
-Zend Framework 1.12.13 was released, in order to fix a regression issue introduced in 1.12.12 release.
+**Q: Was there a follow-up release after 1.12.12?**
+A: Yes, Zend Framework 1.12.13 was released on May 20, 2015, to fix a regression issue introduced in the 1.12.12 release.
 
-[Release Announcement](http://framework.zend.com/blog/zend-framework-1-12-13-released.html)
+**Q: Where can you read the official announcements for these releases?**
+A: The 1.12.12 announcement is linked as "Zend Framework 1.12.12 Released", and the 1.12.13 regression fix announcement is linked as "Release Announcement".