What is ObjectForm For Developer

What is ObjectForm?

ObjectForm is a mulit-platform Model View Presenter (More of a Supervising Controller pattern) rapid application development PHP Framework. It provides well thought out solutions to common challenges when creating web applications.


1. Security = Making sure your data is safe

2. Compatibility = Making sure written code doesn’t have to change when upgrading. 

3. Scalability = Making sure as you start small and grow, the software is ready to handle larges amounts of traffic

4. Manageability = Making sure changes in your software is well organized and easily maintained

Development Team Values and Beliefs

  • We believe that no data is good unless it’s valid. All input is always dirty until cleaned
  • We believe that code shouldn’t not be cut and paste. That’s what functions and loops are for.
  • We believe a developer should be able to use any type of tools or coding methods they want to use anywhere in a project
  • We believe in strict standards and protocols inside the framework itself
  • We believe in open platforms and standards in data exchange. Any and all formats are good to support.
  • We believe that simple is better than easy. Though it’s great to have an easy interface when available.
  • We believe in the right tool for the right job. We did not find object oriented programming paradigm to be a good fit for our goals. We found it slow down our development process as well as PHP having too many files and classes to manage. However we did find a need for inheritance to provide the best platform. We try to keep to a small number of larger objects to use this tool of inheritance where appropriate and needed. This also eliminates the requirement to know advance OOP patterns to develop on our platform.
  • We believe in structured and declarative programming. Declaring an intent and an order then letting the computer figure out the best path of execution. We feel that having the programmer control the order is essential to testing and debugging. 
  • We believe the programmer should write all his code not a program. We’re a strong supporter of high level abstraction, you lose any abstractness as soon as you start editing generated code (Looking at you scaffolding). We’d rather keep the high abstracts and allow the framework to make choices on how to efficiently execute your high abstracts and give the high level description the freedom to change without having to rebuild all the lower code by hand.
  • We believe in high-level asynchronous parallelism. Splitting up the biggest task into a bunch of smaller tasks gives good separation and modularity to help scale projects.   
  • We believe in abstractions. We want to give the user enough reason to use our version of functions of PHP. These abstraction provide more benefits than disadvantages and are key to growing a small project into a large one.
  • We believe in data access layers but do not believe in mapping them on to objects. We use a a relation model in our platform, not an object-based one. Simple queries can be abstracted but complex queries are best written and maintain in pure SQL. All programmers should develop strong SQL skills because as soon as the database is an extension of programming data structures and when it fails the program fails.
  • We believe in seamless preprocessing. We try to do as much work up front as possible the first time and cache it for future re-use. And when that cache is no longer valid, we seamlessly and automatically invalidate the cache and regenerate it again.
  • We believe that a library isn’t complete without a detailed efficient API and a quick and dirty one. 80% of your performance bottleneck is going to be in 20% of your code. So efficiency matters less in the majority the code.
  • We believe in a balance between verbose and terse syntax
  • We don’t believe in having a scripting language in a scripting language. Some presentation and template systems allow you to mix logic and presentation. Having to learn a new scripting system when you already have PHP is self-defeating. Designers should not have to be programmers.
  • We develop on old hardware with the latest software. Developing on a 75 mhz pentium development server is the best motivation for your developers to do their job right. This also helps ensure, when you’re attacked with hundreds of users on your beefy big iron box, you don’t have to worry about much.
  • We believe that you shouldn’t have anything loaded in memory you don’t use. Our small simple modular core can be extended as needed to help provide this. The smaller the active footprint, the more you can do.
  • We believe that difference situations call for different resource prioritization. When you starting out response time maybe more important than memory usage. When you need to server a large amount of visitors, memory usage maybe more important than response time. Our framework is built to be flexible and adjustable, so it’s not one paradigm fits all.
  • We believe projects get smaller and more efficient a byte at a time. No matter how much hardware you have, if it has to do more work, its wasteful.
  • We believe in expert systems for advanced analysis. There are so many variables and functions in a modern script that it becomes improbable for a human to keep it in their heads (or at least being able to pay active attention to it all). Adaptive analysis and control can continue where the coder left off.
  • We believe old tricks and optimizations never go out of style. Some of the most creative tricks have come from the hardest limitations but didn’t stop coders of the past from achieving new feats. Their genius solutions are just as good today as they were decades ago. Though they’re not always necessary on modern hardware, they can deliver amazing results.
  • We believe web pages should be complete at server, not compiled on the client side. This provide the easy parsing and understanding of the delivered pages.