-
Notifications
You must be signed in to change notification settings - Fork 24
10 Questions About Mach II
- What is the essence of Mach-II in a sentence or two?
- Tell us more about the main features!
- How did Mach-II come about and what was the reason for creating it?
- When should a developer seek out Mach-II?
What has it got going for it? - What are the pre-requisites for using Mach-II?
Is there any prior knowledge that would help new users?
Does it use any other frameworks that could simplify or complicate things? - What sets Mach-II apart from other frameworks?
- Are there any great examples of Mach-II "in the wild"?
- What about licensing, community, support and documentation?
- What's coming up in the future for Mach-II?
- Where can people find more information about Mach-II?
Mach-II is an event-driven, object-oriented, implicit invocation, MVC framework for CFML that is focused on handling the basic plumbing of CFML applications.
Buzzword overload? Let's try something simpler: Mach-II is designed to give CFML developers a high-performance, extensible, proven framework they can use build highly flexible, highly maintainable applications.
The main feature and characteristic of Mach-II is that it's an object-oriented (OO), event-driven framework. The event object is at the core of everything that happens in a Mach-II application. This makes things very handy for developers because all URL and form variables involved with any request automatically get put into a single event object, and data can also be put into the event object programmatically. The net result of this is that developers never have to worry about the scope in which their data will exist, because all data for the request is always going to be contained in this single event object.
One thing that sets a Mach-II application apart from procedural CFML applications is that all actions in a Mach-II application are event announcements, so there is no concept in a Mach-II application of linking to a specific CFML file. The big advantage here is flexibility. Events are announced, either in the URL or programmatically, and this subsequently kicks off a series of developer-defined actions for that event, such as data processing or gathering data and displaying it to the user.
As events are announced in the application, the developer has total control over what occurs during the course of the processing of that event, and the details of what occurs during the event are defined in XML configuration files. This gives developers a great deal of flexibility in the handling of events. The benefit of this approach is if something about the event handling needs to change, Mach-II is highly flexible and allows for what we like to call "low impact maintenance." What this means is that developers can make changes, even relatively major ones such as the flow of an event, without negatively impacting the application as a whole.
Mach-II also has several extensibility features that allow developers to layer additional functionality in their applications in a highly modular way. Filters and plugins, for example, have been in Mach-II since the first version of the framework, and more recently we've added modules, subroutines, and XML includes for even greater extensibility.
Filters can be applied on a per-event basis and allow for an event to be short-circuited based on the runtime state of variables. One use of a filter might be to determine whether or not a particular user can view a particular record in a database. This user might have access to view some data but not other data that is accessed via a common event announcement, but by applying a filter to this event, the user's ID could be checked to see if the user can view the record they are trying to view. If they can't, the event processing can be stopped for particular records, while it would be allowed to continue for records to which the user does have access. Because this logic is implemented in a filter, the filter can be layered on top of an event without having these security and flow concerns infiltrating the business logic.
Plugins are similar to filters in that they offer a way to layer functionality on top of events, but unlike filters, plugins are automatically executed on every event as opposed to being applied to specific events. Plugins are great for things like security, because a plugin can be added to an application that would stop users who are not logged in from accessing any events other than a login screen. This is a great way to apply security to an entire application in one place, which means security can easily be adjusted for the entire application. Plugins also offer access to specific execution points during the course of an event, so developers have extremely granular access to be able to execute code and any point during the course of the event.
Modules are a extensibility feature of Mach-II and allow for entire sections of applications to be built independently of one another, yet all still be part of the same parent application. This is a great way to build large-scale applications because independent teams can work on separate sections of the application such as accounting, reporting, authentication, etc. and not have to worry about things like conflicting event names. This is also a great way to scale the size of Mach-II applications because new modules can easily be added to existing applications without disturbing existing functionality.
To summarize, the biggest features of Mach-II are its event-driven architecture and its extensibility. This philosophy has allowed us to grow the framework over the years, and also allows developers to easily grow their Mach-II applications.
Mach-II was originally developed by Ben Edwards and Hal Helms in 2003, and is the original OO framework for CFML. Mach-II was originally called "Fusebox MX" because it was intended to be a Fusebox-like framework that would leverage the new object-oriented capabilities of CFML when CFCs were added to the language. Soon after starting on development, Ben and Hal realized the framework was turning into something completely different from Fusebox, and decided to rename it Mach-II. The "II" in the name actually stands for "implicit invocation," which is one of the core architectural principles of Mach-II.
In 2005, Hal and Ben asked Matt Woodward to become the release coordinator for the next release of Mach-II, and soon thereafter Peter Farrell was added as a contributing developer on the project. Matt recently transitioned into a new role on the project of community manager and contributing developer, and Peter is now the lead developer. We also added Kurt Wiersma to the core development team, and this team is responsible for all Mach-II releases since version 1.1.0, which was released in 2005.
In 2007, Peter's company, GreatBizTools, LLC, became involved with the project and now offers commercial support and official training for Mach-II. Peter, Kurt, and Matt developed and delivered the first official Mach-II training prior to the cf.Objective() conference in 2008, and this training will take place in other locations throughout the year. For example, we offered an abbreviated version of the training at the BFlex/BFusion conference in Bloomington, Indiana in September, 2008, and have plans for complete training courses in other locations in the U.S.
Peter, Kurt, and Matt continue to serve as the core Mach-II team, but we are in the process of expanding the team a bit so we can offer even better community support and improve the quality and quantity of our documentation. For example, we added Brian FitzGerald as the Wiki Manager recently. We'll have even more to say about this soon.
Probably the biggest thing Mach-II has going for it is how much is eases the pain of maintenance. If we as developers do our jobs well, the biggest chunk of time in the lifespan of our application isn't the development phase, it's the maintenance phase. Mach-II helps speed up the development process because developers don't have to reinvent the plumbing for each new application, but where Mach-II really starts to shine is when changes need to be made to the existing features of an application, or when new features need to be added.
Because of the way Mach-II applications are architected, and because of the flexible nature of the event-driven concept, it's quite painless to make rather radical changes to an application. The panicked thought of "If I touch this, what's going to break?" that we've all had as developers simply isn't a concern because of the modular nature of Mach-II applications. This of course means that existing features can be changed as much as necessary and new features can be added, and the only piece of the application that will be impacted is the piece that's being changed. This gives developers a great deal of freedom and confidence when making changes to existing applications.
Developers should also seek out Mach-II if an application that started small is getting larger and becoming difficult to maintain. I'm sure we've all been in this situation as well, that what was supposed to be a quick prototype is now a heavily used production application and users are clamoring for new features. If the application was initially designed as a prototype, chances are expanding and maintaining the application wasn't part of the original architecture. With Mach-II an application can start small and be developed quickly, but also have infinite extensibility through things such as filters, plugins, and modules. Applications rarely get smaller over time; they always grow!
In short, if developers are losing sleep over maintaining their applications because they've become fragile, or they're concerned about how to expand their applications over time, Mach-II is designed to address these concerns.
What are the pre-requisites for using Mach-II?
Is there any prior knowledge that would help new users?
Does it use any other frameworks that could simplify or complicate things?
Developers coming to Mach-II should have a decent understanding of OO principles, because developing a Mach-II application more or less mandates that developers be doing OO development as opposed to procedural development. Since we should all be doing OO development at this point anyway, we don't see that requirement as a bad thing. That being said, we always tell people that diving into Mach-II is not a particularly good way to learn OO development, and this is also why in our training courses we spend the better part of a day on general OO concepts because having a good grasp on OO is very important to being successful with Mach-II. It really isn't as daunting as it sounds, however. Most people who've taken Mach-II training have told us they got up to speed very quickly with the fundamental OO knowledge we provide in our training courses.
Mach-II does not rely on any other frameworks directly, but many developers leverage ColdSpring in conjunction with Mach-II, and this is a very powerful combination
Mach-II is specifically designed to be easily extensible, and this is illustrated through the ease with which other frameworks such as ColdSpring can be leveraged within Mach-II applications. To integrate ColdSpring with Mach-II, for example, it's as easy as enabling one of Mach-II's property CFCs.
In Mach-II 1.6 we added comprehensive and powerful caching and logging functionality that both can be used as standalone frameworks outside of the context of Mach-II. While these aren't technically separate frameworks, this again points out how we build everything in Mach-II in a very modular way. This allows the core framework to stay as clean and lightweight as possible while allowing for powerful extensibility, and things like caching and logging can be added without getting into the guts of the framework itself.
We think Mach-II's long history is a big thing that sets Mach-II apart from other frameworks. Mach-II is the original OO framework for CFML and has continued to innovate while remaining true to the ideal of keeping the core framework small and offering extensibility through its architecture. Ben Edwards did a fantastic job of creating a rock-solid core for the framework that we've been able to build on over the past several releases. Every time we add a new feature and see how elegantly this can be accomplished we realize how fundamentally sound Mach-II is at its core.
The other major thing we feel Mach-II has going for it is its extensibility features. This started with filters and plugins which have been available since the first versions of Mach-II, and these features offers developers simple yet powerful ways to extend the framework in their applications. In more recent versions of Mach-II we've added things like property CFCs and modules, and the new caching and logging features in Mach-II 1.6 follow this same model. Modules in particular are very helpful on large applications because developers can break applications down into logical sections, develop them independently, but have them all interact as part of a single Mach-II applications. Mach-II users building large applications have told us time and again that modules are their favorite architectural feature of Mach-II.
Plenty! Mach-II has been around for a long time now and has very wide adoption. To give some examples, parts of adobe.com are built in Mach-II, including the very high traffic "Site of the Day" section. Numerous internal applications at Adobe are also built on Mach-II.
An example of a recent high-profile site launch is TunesBag.com, which is an extremely high-traffic and innovative music sharing/social networking service based in Austria. It's received a lot of press recently in both the U.S. and Europe, and according to Hansjoerg Posch who created TunesBag.com, Mach-II "rocks!"
Mach-II is also powering the ambitious ground-up creation of a content management system at Forum Communications Interactive - FCI. Forum is media company with large network of mid-western newspapers and few a radio/TV outlets. In the case of this, FCI is using Mach-II to build a custom CMS that will be used by all media properties websites for effective advertising and content management. Of course the amount of traffic newspaper web sites receive is quite high so they are taking full advantage of the new caching features built into Mach-II 1.6.
Mach-II is used heavily in numerous commercial applications, particularly where maintenance of large CFML applications had become an issue. One example of this is Unitrin Specialty, which is part of Unitrin Group, a company that had over $3 billion in revenue in 2006. Unitrin Specialty is a major high-risk auto insurance company. They use Mach-II to handle their online payments and this accounts for 65% of the company's total payments. Mach-II-powered applications also handle claims, reports, policy management, and numerous other processes. According to one of their developers, the use of Mach-II "drastically cut down on maintenance time" as well as the time it takes to introduce new features into their system. This is great to hear because that's exactly what Mach-II is designed to do.
Government agencies and educational institutions are also heavy users of Mach-II. Examples of government and educational agencies using Mach-II include applications at the Environmental Protection Agency (EPA), NASA, Johns Hopkins Bloomberg School of Public Health, the United Nations and many others. At the EPA they're developing all their new business systems in Mach-II and are also converting all their old applications to Mach-II. This is a great example of the power of a framework, because once everything is standardized on Mach-II, developers can hit the ground running when working on any application even if they didn't build the application originally.
Johns Hopkins Bloomberg School of Public Health uses Mach-II as the "backend glue" for their training and education applications, which are, quoting one of their developers, "used by thousands of public health professionals every year, helping to improve the quality of life for millions of people worldwide." We take great pride knowing that Mach-II is a part of this effort.
UN Environment Programme is using Mach-II for their library/archive of graphics on sustainable development and environment. It is currently their most popular site and receives a fair bit of traffic.
Other examples of Mach-II in the wild include Allura Direct, a Canadian vacation rental portal with 70% of their applications currently on Mach-II 1.6 and plans to be 100% on Mach-II by the end of 2008; avonthor.com, a rapidly developed Mach-II site that leverages modules for the secure administrative portion of the site; Monument Snowboards, which uses Mach-II to power their CMS; and DuroDesign Flooring, a [specialty flooring company that manufactures green flooring][idext_duro-design] and uses Mach-II for their website, which serves over 3 million requests a year on a small VPS server.
To cite just a couple of other examples, Creori, Inc. uses Mach-II in the majority of their projects. Mach-II drives their ecommerce engine which powers sites such as SeaVees) and [Friend or Foe](idext_yourfriendorfoe]. They are about to launch a completely rewritten version of the ecommerce engine using the new features of Mach-II 1.6. They also built a CMS in-house using Mach-II.
There are numerous other examples of high-profile public Mach-II applications, but hopefully these serve as a good cross-section of the types of companies using Mach-II and the benefits they're experiencing. Mach-II performs extremely well on high traffic sites, and the new caching features in Mach-II 1.6 take Mach-II's performance strengths to the next level. We were excited to see the number of developers and companies writing applications on Mach-II 1.6 even before it was released as a beta. The early uptake was crucial in improving the framework during the development cycle and allowed us to catch any defects or edge cases early.
Mach-II is completely open source and free to use, and is released under the Apache 2.0 license, which means CFML developers can use Mach-II on all types of projects, both commercial/closed source as well as open source. Open source licensing can get confusing, so the bottom line is Mach-II is free to use for any CFML application.
One of the things we pride ourselves on with Mach-II is our community and our support. The Mach-II Google Group has 620 members and is still growing strong, and Team Mach-II provides as much support as we possibly can through the Google Group. We're also expanding Team Mach-II to include some of the community members that have done a fantastic amount of work on the documentation housed on our rapidly growing wiki. Documentation can always be improved of course. Though, we are focusing on documentation and sample applications.
As mentioned earlier, GreatBizTools also offers commercial support and training for Mach-II, which in our opinion is very important for both the Mach-II project and our users. In some corporate environments open source projects are seen as a negative due to the lack of commercial support, so making commercial support available for Mach-II has proven very helpful in addressing these concerns. We've already have numerous companies take advantage of this with great success. The group and on-site training we offer is another aspect of this, because we want our users to be successful with Mach-II over the long term.
We're going to continue getting people information on new features as early as we can, which we feel is vital to the transparency and openness of truly open source projects. As we did with Mach-II 1.5 and 1.6, for Mach-II 1.8 and 2.0 we will release feature specifications as soon as they're more or less fully baked in our heads, but before we've written any code. This lets Mach-II users give us feedback very early in the development process so that we can make changes to the specifications as needed to better meet the needs of our users. We firmly believe this is the best way to run an open source project, particularly an open source framework project, because developing features in a back room somewhere and announcing them when they're completely coded is not good for us or for Mach-II users.
The other thing we're going to do with future releases of Mach-II is do smaller releases more frequently. Mach-II 1.6 (currently in RC2 with a final release very soon), even though it's only a "dot release" in terms of the version number, introduces caching, logging, and numerous other new features, so it's a very big release of Mach-II. Future releases will focus on smaller pieces of functionality, getting them fully developed, and releasing them so we can get new features in the hands of our users much more quickly.
In terms of future releases, we have a maintenance release, which will probably be version 1.8, targeted for release early in 2009. Following that we'll begin work on Mach-II 2.0, for which we have some very cool features planned. We'll make our initial specifications on these new features available as soon as we work out some of the details, and then the all-important feedback loop with our users can begin.
The official web site is at http://www.mach-ii.com, where people will find great articles, tutorials, sample applications, and numerous other resources. People can also join the Mach-II Google Group. It's a low-traffic, high-quality group where people can feel free to ask any and all questions about Mach-II.