Cherrycake
ExamplesGithub
version 2.x alpha
version 2.x alpha
  • Introduction
  • Status
  • Changelog
  • Migration
  • Architecture
    • Basics
    • Modules
    • Classes
    • Lifecycle
      • Deep lifecycle
    • Performance
    • Security
    • Patterns
      • Files structure
    • Items
    • Server requirements
  • Guide
    • Getting started
      • Skeleton start
      • Docker start
    • Modules guide
    • Classes guide
    • Actions guide
      • Complex actions
      • Variable path components
      • Accept GET or POST parameters
      • Getting the URL of an action
      • Cached actions
      • Brute force attacks
    • Patterns guide
      • Passing variables to a pattern
      • Nested patterns
      • Cached patterns
    • Cache guide
      • Time To Live
      • Using cache
      • Lists
      • Queues
      • Pools
    • Database guide
      • Basic queries
      • Prepared queries
      • Cached queries
      • Cache key naming
      • Removing queries from cache
    • Items guide
      • Item cache
      • Item lists
      • Items custom filters
      • Items custom ordering
      • Mixing filters and ordering
      • Items with relationships
      • Items cache
    • HtmlDocument guide
    • Css and Javascript guide
      • Modules injecting CSS and JavaScript
    • Session guide
    • Login guide
      • Creating a complete login workflow
    • Locale guide
      • Multilingual texts
      • Domain based site localization
    • Log guide
      • Loading Log events from the database
    • Stats guide
      • Stats events with additional dimensions
      • Loading Stats events from the database
    • Janitor guide
      • Janitor tasks configuration files
    • Command line interface
    • Debugging
  • Reference
    • Core modules
      • Actions
        • Actions methods
      • Browser
      • Cache
        • Cache methods
      • Css
        • Css methods
      • Database
      • Email
      • Errors
      • HtmlDocument
        • HtmlDocument methods
      • ItemAdmin
      • Janitor
        • Janitor methods
      • Javascript
        • Javascript methods
      • Locale
        • Locale methods
      • Log
        • Log methods
      • Login
        • Login methods
      • Output
        • Output methods
      • Patterns
        • Patterns methods
      • Security
        • Security methods
      • Session
        • Session methods
      • Stats
        • Stats methods
      • SystemLog
      • TableAdmin
      • Translation
      • Validate
    • Core classes
      • Action
        • Action methods
        • Action properties
      • AjaxResponseJson
      • BasicObject
        • BasicObject methods
      • CacheProvider
        • CacheProvider methods
      • Color
      • DatabaseProvider
        • DatabaseProvider methods
      • DatabaseResult
        • DatabaseResult methods
        • DatabaseResult properties
      • DatabaseRow
      • Engine
        • Engine methods
        • Engine properties
      • Gradient
      • Item
        • Item methods
        • Item properties
      • Items
        • Items methods
        • Items properties
      • Image
      • JanitorTask
        • JanitorTask methods
        • JanitorTask properties
      • LogEvent
        • LogEvent methods
        • LogEvent Properties
      • LogEvents
        • LogEvents methods
      • Module
        • Module methods
        • Module properties
      • Response
      • Request
        • Request methods
      • RequestParameter
        • RequestParameter methods
      • RequestPathComponent
        • RequestPathComponent methods
      • Result
      • StatsEvent
        • StatsEvent properties
      • StatsEvents
        • StatsEvents methods
      • SystemLogEvent
        • SystemLogEvent methods
        • SystemLogEvent properties
      • SystemLogEvents
        • SystemLogEvents methods
  • Code conventions
  • License
  • Extras
Powered by GitBook
On this page
  • Applications
  • Philosophy
  • Purpose

Was this helpful?

Introduction

Cherrycake is a low-level programming framework for developing modular, efficient and secure PHP web applications.

Instead of a comprehensive, all-in-one web app building environment, Cherrycake aims only to provide a strong foundational layer and methodology that feels comfortable, rational and easy to use while prioritizing this three main goals:

  • Modularity

    • Provides scalability, standardization and code tidiness.

  • Performance

    • Maximizes response times and reliability even in very high traffic scenarios.

  • Security

    • Identifies, blocks and reacts to known attack vectors.

Cherrycake is aimed at curious developers and students in the mood for creating a new framework or learning about techniques to do so. If you're one of those, Cherrycake can bring you inspiration, and maybe even provide a foundational layer you can build upon.

Because Cherrycake is not being maintaned by a big or active community like other akin frameworks, it's not recommended for production use, and is presented only for educational purposes.

Applications

Because Cherrycake sits and stays at the lower level of the server application, it provides you with a clean slate to build any kind of website, but also: API endpoints, client-server architectures, proxy-like architectures, resource serving services, servers for system interfacing or batch processors for example.

Because of this architecture, Cherrycake might come in handy when building websites of any complexity, but could also be a great partner for your client-side JavaScript application by providing the API it needs. Similarly, Cherrycake might be a good starting point if you're experimenting with new ways of using the Internet, or it could even be a strong foundation if you're developing your own server application programming framework.

Philosophy

Server web app programming frameworks that reach higher implementation levels come inevitably with some loss of control and detachment from the finer details in favor of practicality, standardization and improved development speed. For the vast majority of developers this loss of control is negligible, and the benefits they provide far outweigh the loss.

Cherrycake is recommended to web developers who prefer to stay closer to the metal to regain control of every possible finer detail of their application, at the expense of the benefits of higher level frameworks.

Very often, this need of control, more than a rational or optimal decision, is simply an emotional manifestation of passionate programmers who enjoy digging deep in the understanding of how a system works and how it can be improved, who like to defy standards and enjoy coming up with their own solutions, even when there already are solutions available.

In that sense, even though Cherrycake also provides many higher level modules, it's defined as a low-level framework because instead of aiming to provide a suite of ready-made solutions for an optimized development cycle, it focuses on providing a strong foundation for you to create them.

Purpose

Cherrycake is not a replacement for fully-fledged, widely-supported and well-known frameworks like Laravel or Symfony. If you're looking for alternatives to those frameworks, you're looking in the wrong place!

NextStatus

Last updated 1 year ago

Was this helpful?