This is an opportunity to sit down with an experienced ZF architect for a hands-on session where we’ll build an application from the ground up. Starting with Zend_Tool, we’ll build a basic MVC application in Zend Framework over the course of the tutorial. Along the way we’ll delve deeper into some of the most powerful areas of the framework with routing, data access, forms and caching all being covered in some depth. By the end of the session you will have seen and used the key framework areas and be ready to apply these skills to your own applications.

Writing maintainable code is an art that takes effort and practice to master.
Part of that art is learning what tools and strategies will assist you in that
effort. In this tutorial, we will cover a variety of practices and tools that
can make your life, and the lives of your team members, easier as you develop
your applications. Among them, we will provide overviews of:

• Version Control
• Coding Standards
• Unit Testing basics
• QA tools: phpcs, phploc, phpmd, continuous integration, and more
• Team Collaboration tools, such as Skype, IRC, issue trackers, and more

Most PHP developers have at least dabbled with JavaScript – used a jQuery plugin to add tooltips, or maybe a simple AJAX call to pull data from a PHP backend service. As the client side gets heavier and more complex, though, PHP developers would be well-served to delve deeper into JavaScript, and gain an understanding of this increasingly popular language. Thankfully, JavaScript is an interesting, concise language that’s very well suited for front-end development – and other tasks.

In this tutorial sessions, we’ll cover:

• The JavaScript Core language, aka JavaScript is NOT the DOM API
• How JavaScript is NOT PHP
• What you’ll love
• What you’ll miss
• What you’ll hate
• The JavaScript object model, aka Forget Everything You Know about OOP
• Function-oriented development, aka Functions RULE
• Inheritance via prototype
• The malleability of JavaScript
• JavaScript in the browser: The DOM, Event and XMLHTTPRequest APIs (and more)
• Using a framework to make browser-based JS development less than a complete nightmare
• Server-side JavaScript, aka Traitorous Development

In this workshop, two PHP experts with different software engineering focuses will perform an interactive code review together with the audience. Attendees of this lab will learn how experts look at code what good code and bad code looks like, and how to avoid the most common gotchas. They are invited to bring their own code for an anonymous code review for an increased benefit from the workshop.

Not knowing what attackers do makes writing secure web applications a tough job and learning all the tiny details as well as the important tricks pretty much impossible. This hands-on tutorial will demonstrate how hackers work when attacking a website, giving you first hand information on every day security problems. You will learn how to secure your own website and what else to consider in protecting your environment in general.

MongoDB a popular, easy-to-use NoSQL database. It is powerful enough to be a replacement for MySQL and fast enough to replace Memcached. It is being used in production at Sourceforge, EA Games, Github, The New York Times, and tons of other companies. This introductory tutorial will get you started using MongoDB; in particular, we will cover:

• When to use Mongo (and when not to)
• How to get started with Mongo from PHP
• Basic usage – everything you need to run an app on MongoDB
• Getting more out of MongoDB with indexing, MapReduce, geospatial queries, etc.
• How to think non-relationally and migrate your schema to a schemaless database
• Putting it all together in a MongoDB-powered app

Lots of changes are made within PHP between feature releases but most aren’t made public until the last minute. This session will help decipher and show code examples for all of the new features in the next feature release of PHP.

Continuous Integration with automated code analysis and test execution has seen broad adoption in recent years. The ideas behind this have changed how companies look at Build Management, Release Management, Deployment Automation, and Test Orchestration.

This session presents the best practices and available tools that provide an insight into the development progress and code quality throughout the development lifecycle of PHP-based software projects.

While PHP unit tests usually cover all the important aspects of the backend, webbased frontends require a different approach to testing – especially if javascript and client-side user interactions are to be tested. This session will introduce you to the powerful Selenium IDE and testing framework that lets you remote-control almost any browser. You will learn how to create robust tests, using xpath as well as css selectors and how to integrate these tests with phpunit.

Today’s biggest and most popular PHP applications go far beyond the traditional LAMP components of Linux, Apache, MySQL, and PHP. To deliver a rich, high-performance, and reliable experience, they integrate:

• reverse proxy caching
• local and cluster-wide object caches
• non-relational persistence engines
• application deployment and systems management tools
• full-text indexing systems
• database replication support
• monitoring
• non-PHP services

Every layer of the stack is expected to be highly available and horizontally scalable. Unsurprisingly, assembling these layers ad-hoc is a recipe for incompatibility, application integration complexity, high management overhead, and redundancy. This presentation will outline a “golden” application stack (using the best free, open-source solutions from May 2010) that efficiently provides these facilities to PHP applications with reliable real-world performance and proven PHP application integration strategies that developers will love.

Come listen to leading Rich Internet Applications (RIA) experts from the Microsoft and Adobe sides of the RIA space discuss many of the best and worst practices when building RIAs. RIAs provide a similar user experience to traditional desktop applications combined with the ease of deployment of web/browser based applications. This produces a fair amount of confusion because there are a number of potentially conflicting practices depending on whether you approach your RIA as a desktop or a web application. This session dives into the definition of RIA and walks through the best and worst practices that have appeared over and over again. We will explore architectural patterns and practices such as state management, fault tolerance, service composition, communications protocols and message formats and goes into details on how RIAs can be developed using runtime environments such as Adobe Flex or Microsoft Silverlight.

Come play with me as we learn all we need to know about replication. We will discuss how replication works, the difference between the various types of replication (RBR, SBR, Mixed Mode), how to set it up, monitor it, handle breaks in replication, and more.

Implementing software development “best practices” can be a challenging feat, especially if you are in a very small team of developers. Little to no budget, stress to just “get something out”, and lack of understanding from management of what you really do means you have to make sacrifices, right? This talk will give you some insight on accomplishing your goals of being a top-rated development shop, even if you are an army of one. From justifying those best practices to utilizing free services to hiring additional help, this talk will run the gamut of running a software development shop at a small scale.

Although PHP is traditionally a web-only language, that doesn’t mean that it
can only be used for web applications. This presentation will show you how PHP
can be used on embedded devices—running on Linux. I will cover some basics for
GUI design (with PHP-GTK), but also cover issues that come along when you have
to take care of low-memory, low-bandwidth situations as well as restrictions
with input methods. In those cases solutions need to be picked to make the whole experience on embedded devices usable.

Tree-like data relationships are common, but working with trees in SQL usually requires awkward recursive queries. This talk describes alternative solutions in SQL, including:

• Adjacency List.
• Path Enumeration.
• Nested Sets.
• Closure Table.

Code examples will show using these designs in PHP, and offer guidelines for choosing one design over another.

The Web is a vital part of our daily lives, and as we begin using the Web for tasks traditionally performed on the desktop, such as word processing, software as a service (SaaS) and software + services models are becoming more important. Web developers are caught in the cross hairs of these merging industries. They have the know-how of web development but, often, none of the skills for traditional desktop or mobile development.

Enter Titanium. Appcelerator Titanium is an open source platform for developing native desktop and mobile applications using the web technologies you’re already familiar with. Now, web developers can use their skills to develop for both the Web and desktop/mobile platforms. Ben Ramsey will demonstrate how to create a simple application in Titanium Desktop, showing examples using JavaScript and PHP working together in the Titanium run time environment to power dynamic desktop applications that communicate easily with external web services.

One of the most underrated PHP extensions is likely the SPL or Standard PHP Library. With its initial introduction in PHP 5, it offered a number of iterators, interfaces, and exceptions similar to those of the C++ Standard Template Library. In PHP 5.3, the SPL gained several new additions: a number of container classes were introduced with specialized algorithms to increase performance for specific applications. This presentation provides background on the goals of the SPL as well as some of the components included in its initial release in PHP 5. It reviews information on data structures as they relate to SPL containers, the high-level algorithms associated with them, and their appropriate applications. Example use cases and current benchmarks versus traditional arrays for each component are included. The presentation assumes no formal education and is suitable for novice and intermediate level developers with little or no experience with SPL or data structures in general.

While managing your Apache server may not be your primary job responsibility, you need to know your way around your Apache server in order to do your job. In this talk, you’ll learn how to do, or do better, a variety of things that come up every day in the life of an Apache server administrator, as well as learning about some of the less well-know features that maybe you weren’t aware of at all.

Rich is the author of ‘Apache Cookbook’, from O’Reilly, and spends an inordinate amount of time answering Apache questions on IRC.

Drawing on experiences of running large websites and blogs, this
session will discuss numerous tactics that you can use to keep spammers
and gamers at bay. Removing comment spam, stopping people from
artificially inflating the rank of items on voting sites, and so on will
be discussed. Some specific technologies and how to interface with them
will be mentioned, but also generic discussions of base theory, that you
can use to apply to your own website where you see fit.

Programmers seem to have a fairly good grasp on ‘how to write code’,
but not always what to do with it once it’s been written. This talk
with delve into details about how to manage your codebase, and how to
manage releases (often intertwined). It will cover topics of coding
standards and focus heavily on how you choose to use versioning tools to
handle your development and release processes. It will have a distinct
Subversion(SVN) flavor to the talk, but the concepts will not be
specific to SVN.

Until recently, Relational Databases have been the rage… but now there’s a new
kid on the block: the NoSQL database. NoSQL databases turn the conventions we’ve
all learned on their heads: data normalization, pivot tables, schemas, and more.
Instead of storing metadata and relations across tables, we can create custom
schemas per record — offering incredible flexibility and reducing the number of
queries required to get at exactly the information we need.

In this talk, we’ll look at some of the advantages and disadvantages of NoSQL
databases, as well as some examples of applications that could benefit from the
new paradigms they offer.

Many of the most popular web applications today deal with highly organized and structured data that represent entities, and the relationships between these entities. LinkedIn can tell you how many degrees of separation there are between yourself and the CEO of Samsung, Facebook can figure out people that you might already know, Digg can recommend article submissions that you might like, and LastFM suggests music based on your current listening habits.

We’ll take a look at the basic theory behind how some of these features can be implemented (no computer science degree required!), and then dig in to a few practical implementations using an PHP & and a relational database, as well as with a document oriented database (Riak through PHP bindings). Lastly, we’ll take a quick look at the current landscape of graph-based datastores that simplify many of these operations.

“Are we there yet?” “Are we there yet?” “How ’bout now?” Ever go on a trip where someone is impatient and continues to badger those around them with questions about how quickly we’re arriving? It’s annoying, yet this is how most modern web applications work! Stop the insanity and learn how you can use XMPP (eXtensible Messaging and Presence Protocol), one of they key components of Google Wave, in your applications today.

Psst. Have you heard about MySQL 5.5 yet? Are you hitting CPU bottlenecks, InnoDB locking and memory management issues or scalability issues with MySQL 5.1? Maybe you need to take a look at what is coming with 5.5 and all it can give you…

Git is hard; at least if you listen to the naysayers. Actually, you need to know a handful of commands to navigate Git successfully. This talk demystifies Git. Once we’re finished you’ll know everything you need to start using Git in your day-to-day projects and collaboratively with other developers.

Message queuing is an art of handling background and/or asynchronous processing. Most processes can be off loaded to the background for processing. This presentation goes through why message queues are needed, what they help to solve, available software and several demos / code samples. Just think, your boss comes over to you and asks you to support video processing, how are you going to handle it? Message queues are a great way to handle this.

You may have heard of Design Patterns: time tested methods of solving common problems. You may not understand how these apply in PHP to common web development applications. Jason Sweat, author of PHP Architech’s Guide to PHP Design Patterns, walks you through several of the most useful design patterns for web development.

Enterprise is an often abused term in our industry. In the case of development methodologies, it is nearly synonymous with the Waterfall Model of software development. The “blogosphere” is a buzz with the virtues of Agile Development, but what can you do to incorporate this methodology in the face of the high ceremony Waterfall development cycle proscribed by your Megacorp? This talk will not provide all the answers, but it does explore the authors experiences inside of two large organizations.

PHP 5.2 and PHP 5.3 introduce new powerful date and time handling functionality. This new functionality allows you to deal with many issues that arise when you are developing a web applications.

This talk will cover the advanced new functionality only, and will not provide an introduction into PHP’s Date/Time support except for where this is necessary to follow the talk. Examples of things that are covered are dealing with timezones, modifying Date/Time objects’ contents as well as tips and tricks for dealing with storage issues around date and time information.

This session teaches you how to detect and debug PHP scripts with the free
open source tool Xdebug, which is an extension to PHP. The first part will
quickly show how to get started with Xdebug. The second part of the session
will cover detecting problems in your scripts by showing how Xdebug provides
debugging aides in the form of stack/function traces, dumps of variables,
modified PHP functions. In the last part I will show the remote debugger
capabilities of Xdebug with different IDEs, where you can: set breakpoints on
functions, methods and file/line combinations and evaluating error messages.
On top of this you will also see how you can use Xdebug’s profiler to find
bottlenecks in your applications.

Zend_Form is a powerful component than can simplify form handling within your web application. Find out in this session how to make Zend_Form render and validate your form elements and ease the pain of forms on web pages.

We will look at configuration, data filters & validation and error handling. One particularly tricky area is the use of the decorator pattern to control the generated HTML when rendering the form. This session will therefore also take a detailed look at this especially powerful functionality and show how to ensure that your forms are rendered as desired.

All web application frameworks suck.

Some are too complex for the task at hand, and others don’t offer enough flexibility when your application steps outside of the confines of the ubiquitous blog tutorial. As stated by the venerable Sean Coates: “the #1 reason to avoid frameworks: you’ll spend all your time working around edge cases.”

Lithium, a new PHP 5.3+ rapid application development framework started by several CakePHP core alumnus tired of the status quo, is designed to help you get the job done, and get out of your way. Built from the ground-up to cater to people who hate frameworks, it attempts to reduce edge cases, and expose an intelligent public interface that sucks less.

We’ll take a jolly jaunt through the internals of Lithium and examine how we’re leveraging closures, late static binding and anonymous functions made available in PHP 5.3 to write a framework that Sucks Less, including our one-of-a-kind aspect-oriented inspired filter architecture, adapter-based architecture, and first-class support for non-relational datastores such as MongoDB and CouchDB.

Inspekt is a comprehensive input filtering and validation library for PHP. With a focus on simplicity, Inspekt makes writing secure web applications in PHP faster and easier.

Attendees of this talk will learn:

• The Inspekt approach to filtering and validating user input, including the “input cage” concept
• How to ensuring secure code throughout the development process
• How to integrate Inspekt with existing applications
• How Inspekt integrates with popular frameworks like CodeIgniter

Some of the most powerful features of PHP are the most underused. SPL, XML handling, and of course, streams. But what are PHP streams and how can you use (and abuse) them? This is an in depth look at PHP’s streams layer.

Learn about built in PHP stream transports and how to use them (yes, you can do an http request with no curl). See how filters can make a templating system fast and efficient. Take a quick look at how to manipulate sockets and create your own socket server, without an additional extension. Finally learn to create your own stream wrappers and filters, and how to use them.

Whether you’re coding for apache, IIS, OSX, windows, or some exotic operating system and webserver combination usually your PHP code “just works”. But sometimes there are interoperability issues.

Learn some quick rules for installing PHP on different types of operating systems and some basic information about platform differences. Learn how to avoid vendor lock-in with your PHP code by discovering where the trouble areas are and how to avoid them. From cell phones to pdas to desktops, PHP can run anywhere you can compile it, so learn to make your code as flexible and easy to use.

The most massive crime of identity theft in history was perpetrated in 2007 by exploiting an SQL Injection vulnerability. This issue is one of the most common and most serious threats to web application security. Many articles describe methods of defense, but even the advice from security experts seldom tells the whole story. In this presentation, you’ll see some myths busted, you’ll get a better understanding of SQL Injection, and you’ll learn simple and effective techniques to combat it.

With words like community bandied about, what can the individual gain in professional terms from getting involved in extra-curricular activities? Come and hear tales from someone who has almost accidentally benefitted from her community activities about what drives her to get involved and how this has crossed over into her day job. Everyone will take home from this session some new ideas about how giving can actually be receiving, and strategies for situations where everyone wins.

Feeling left behind because you still use subversion? In a world where everyone seems to be shouting “git!”, this session makes the case for continued use of traditional source control in organisations. With a hype-free analysis of the features in the various distributed version control systems and a look at the tools currently available, we’ll also look at how both traditional and distributed solutions meet the business requirements of today and talk about how we can take advantage of them within our existing development setups. Finally, we’ll look at what might influence our decision to move commercial infrastructure away from the traditional subversion repository towards distributed solutions, or not.

Today’s high-traffic web sites must implement performance-boosting measures that reduce data processing and reduce load on the database, while increasing the speed of content delivery. One such method is the use of a cache to temporarily store whole pages, database recordsets, large objects, and sessions. While many caching mechanisms exist, memcached provides one of the fastest and easiest-to-use caching servers. Coupling memcached with the alternative PHP cache (APC) can greatly improve performance by reducing data processing time. In this talk, Ben Ramsey covers memcached and the pecl/memcached and pecl/apc extensions for PHP, exploring caching strategies, a variety of configuration options to fine-tune your caching solution, and discusses when it may be appropriate to use memcached vs. APC to cache objects or data.

From netbooks to smartphones to ebooks, hardware is hitting the road and offering developers all sorts of new ways to interact with users. This talk will go over creating a basic app for a mobile platform based on the Twitter API. We’ll take a deep look at how to use geospatial information (GPS) to keep track of where users and events are. We’ll also cover more general considerations for mobile development, such as security and getting the most out of platform-specific features.

One of the biggest problems of software projects is that, while the practice of software development is commonly thought of as engineering, it is inherently a creative discipline; hence, many things about it are hard to measure. While simple yardsticks like test coverage and cyclomatic complexity are important for code quality, what other metrics can we apply to answer questions about our code? What coding conventions or development practices can we implement to make our code easier to measure? We’ll take a tour through some processes and tools you can implement to begin improving code quality in your team or organization, and see what a difference it makes to long-term project maintainability. More importantly, we’ll look at how we can move beyond today’s tools to answer higher-level questions of code quality. Can ‘good code’ be quantified?

Creating great data visualizations is easy as a PHP developer and is key to creating readable data for your users. This session will cover how you can use some of the more popular PHP charting libraries to turn raw data into meaningful visuals. You’ll also learn how you can use PHP with other technologies like SVG, HTML5, and Flash, to create more compelling, interactive graphics that change context as the user moves through data. Finally, you’ll see how data visualization can be combined with the real-time web to create a visual representation of what’s happening right now.

HipHop transforms PHP source code into highly optimized C++ and then compiles it using g++. It allows developers to continue writing complex logical directly with PHP but leverages the speed benefits of C++. HipHop is more than just a theoretical exercise and currently powers the majority of Facebook servers. This session will cover using HipHop and some of the code changes required to use it.

What’s Microsoft doing to up level the web stack and ensure PHP flies on IIS? What’s the latest with PHP hosted on Microsoft’s Windows Azure Cloud? This talk will give you the latest updates and view into how PHP applications install with Web Platform Installer and run on IIS with WinCache and deploy to the Windows Azure Cloud using a simple command-line tool. We’ll use WordPress as the demo application for this talk.

It’s one thing to bring samples of code to show off and share. It’s something else entirely to write them live in front of a group. Come to this code-along and we’ll break out of the browser to get a crash course in Flex development and interact with the Flickr API. We’ll learn how to authenticate, upload images, add tags, and set privacy for single or a group of photos.

Simplicity is a lost art in the application development space. The Wikipedia definition of simplicity is “Simplicity is the property, condition, or quality of being simple or un-combined. It often denotes beauty, purity or clarity. Simple things are usually easier to explain and understand than complicated ones. Simplicity can mean freedom from hardship, effort or confusion.” This is a beautiful statement that we often lose sight of when we are building our applications. Instead we are on a never ending quest to fill out a checklist of features or to build something clever forgetting about the actual needs of our users to get a specific task done. This session takes complexity to task and challenges you to bring simplicity to the center of your development with some straightforward ideas and guidance.

As a publisher for developers, DZone keeps its fingers on the pulse of the latest trends in the developer world. Using data from our recent member survey, our content, and the patterns of our users at DZone.com, I’ll present 10 trends we’ve observed with developers as we head deeper into 2010. These trends include a shift to more agile methodologies, changes in databases, developer’s version control choices, and more.