We have long been keenly aware of the limitations to static analysis imposed by such a dynamic language as PHP, not to mention the risks inherent in developing software with hphpi and deploying with hphpc. Our experiences with hphpc led us to start experimenting with dynamic translation to native machine code, also known as just-in-time (JIT) compilation … we developed a high-level stack-based virtual machine specifically tailored to PHP that executes HipHop bytecode (HHBC). hhvm uses hphpc’s PHP>AST implementation and extends the pipeline to PHP>AST>HHBC.

He estimates the hhvm bytecode interpreter is approximately 1.6X faster for certain Facebook-specific benchmarks, with still better performance in the offing. But, as described in his blog post on the PHP compilation innovations, there is still work ahead. You can view HipHop-related information at GitHub.

Silverlight is a powerful development platform for creating engaging, interactive user experiences for Web, desktop, and mobile applications when online or offline.

Silverlight is a free plug-in, powered by the .NET framework and compatible with multiple browsers, devices and operating systems, bringing a new level of interactivity wherever the Web works. Silverlight 4 adds a ton of new features, like webcam, microphone, and printing, to enable you to create incredible applications.

This screencast sponsored by Microsoft shows you how to build a basic Silverlight application in order to talk to PHP.

________________________________________________________________________________________

PHPJS is an effort to bring the mammoth PHP API into the land of JS., where it can be used for web apps as well as the increasing number of Javascript applications outside the browser.

The homepage explains some of the philosophy behind this project:

PHP is a language with many high-level functions and while they’re not always implemented as consistently as we’d like (mostly to blame on its underlying C parts), it has a huge following familiar with its syntax so it makes sense to pick its API as a reference. Eliminating the need for our own documentation, thus making life easier, we hope.

We recognize JS – on the other hand – has beautiful language features, and we encourage you to learn them. Never let php.js be an excuse not to.

For the same reason, we’re not porting entire language or control structures of PHP; we stick with the functions.

That said, we think of it as a challenge to port everything and decided to also port low-level PHP functions like strpos even though it may have a JavaScript counterpart (String.indexOf). Cause besides the intellectual challenge for us, porting more also opens up php.js to all kinds of thought excercises and study purposes. And so we leave it up to the developer to decide what to take from this resource. And what not.

It’s not new – the project’s been around a while and went to GitHub last September. However, it’s noteworthy as it appears to be fairly unknown in parts of the Javascript community, judging from recent Twitter responsage to a mention of the project. (It was news to me, and I dabble in PHP.)

Moreover, there is significant progress here: project founder Kevin van Zonneveld yesterday announced CommonJS support. The homepage indicates it’s “first steps”, but longer term, this potentially brings a huge corpus of library functions into the realm of CommonJS, a win for reuse and a win for all the PHPers getting into JS.

The solution to me was to create the charts from HTML using CSS. There have been some solutions for this problem already but I wanted something very simple and easy to maintain. Hence all the markup I am using is this:

Instead of hard-coding any of the trickery necessary I wrote a PHP script to generate the HTML, the styles and do all the math. So all that is needed to render one of the charts is the following code:

Of course, this can also be turned into a web service - you can get the chart with the following URL:

http://icant.co.uk/csscharts/csscharts.php?values=400,20,30,233,312,78,20,67&height=100&width=600&bargap=0

And if you specify JSON as the format you get it with a callback to a function called csscharts:

http://icant.co.uk/csscharts/csscharts.php?values=400,20,30,233,312,78,20,67&format=json

That way you can use it in JavaScript:

You can see some demos here, get detailed info about the CSS trickery used and of course download the code on GitHub. ]]> http://ajaxian.com/archives/pure-css-bar-charts-as-a-simple-api/feed 6 http://ajaxian.com/archives/screencast-php-on-microsoft-iis7 http://ajaxian.com/archives/screencast-php-on-microsoft-iis7#comments Wed, 02 Dec 2009 15:52:21 +0000 tberardi http://ajaxian.com/?p=8094 Read the rest...]]> PHP on Windows has long been held as the preferred development platform for many PHP developers despite the awkward installation process. It has also been assumed that while Apache on Windows isn’t as good as on *nix, it is at least superior (or at least easier) compared to IIS on Windows. With the release of IIS7 and the Web Platform Installer, this is no longer valid. You can setup PHP on IIS7 using FastCGI, which by all accounts is starting to give even Apache on *nix a run for its money! This screencast, sponsored by Microsoft, will walk you through the process of getting an up-to-date development environment up and running with PHP 5.3, MySQL 5.1 and IIS 7.5, on Windows 7.

View the transcript.
=== Links ===

Microsoft® Web Platform Installer

PHP For Windows

Windows Cache Extension for PHP

===Presenter's Bio===

Davey Shafik is a full time PHP Developer with a decade of experience in PHP and related technologies. An avid magazine writer for php|architect and the International PHP Magazine, Davey keeps his mind sharp by trying to tackle problems with his unique perspective. Davey is a seasoned PHP conference speaker, author of php|architect's Zend PHP 5 Certification Study Guide, an original core contributor to the Zend Framework and long time PEAR project contributor.

He lives in Florida with his girlfriend and their 6 cats, where he enjoys the sunshine and working full time in academia while maintaining his off-beat PHP related blog at daveyshafik.com. Davey is Zend PHP 4 and PHP 5 Certified.

Andrea Giammarchi has released Formaldehyde, a new Ajax and PHP error debugger.

Simply grab the project and throw in an inclusion:

You are off to the races.

Want to do a touch more?

We have known about the great FirePHP for quite some time, but this is different as explained. Check it out!

FirePHP solves the problem of AJAX debugging by sending debug information along with the response. To avoid breaking the response content, the debug information is placed into special HTTP response headers. This works for all types of requests, not just AJAX requests, which means you can even debug requests for images that are dynamically generated by a PHP script. You can use FirePHP in your development environment, or use it to track down bugs that only appear on your production site.

This is what Christoph Dorn has to say about FirePHP in his recent writeup.

He goes into detail on how you can setup the Firebug plugin, and how you use it from within PHP:

Check out the article for more info.

In related news, Zend just stepped it up a notch with their new Zend Server that fits in nicely with the cloud.

He shares the new XHR implementation:

and the delves into a PHP server backend that groks things like X-File-Size and X-File-Name.

Then, he shows the client side code to push this all forward and packages it all up:

The external file with sendFile and sendMultipleFile function is in my repository and in the attached zip, while a workable example page with a limit of 1Mb for each file is here in my host.

The UI combines a Vista-like "Start" menu along with an OS X-like dock (using everyone's favorite fish-eye widget). It also has a built-in widget system that leverages Google Widgets. Overall, it's a pretty nice implementation of a desktop and windowing in Ajax.

The framework itself is "GwtPHP" which attempts to take all the advantages of GWT and deploy them to PHP backends in an attempt to solve the problem of limited Java-friendly hosting services. Unfortunately, the framework isn't available for use until sometime in early November.

Dual-License

The developers intend to use the familiar "free for hobbyists, pay up for commercial use" licensing model (what their licensing page calls a "what for what" model).

Give some feedback

Viktor says that they are quite keen to get feedback from folks on the project, so interested folks should get in touch, let them know what you think about the licensing model, and perhaps get early access, etc.

Alvaro Videla just wrote in to tell us about Firesymfony, a Firebug extension that provides an alternative to Symfony's built-in web debug toolbar.

sometimes the toolbar position makes impossible to use some features of the layout of our website, like a link menu on the top right corner. It also happens that while we display a small popup with the resize functionality disabled it’s turns hard to access all the data displayed by the toolbar.

The solution I’ve came up with is to move all the data from the toolbar to Firebug, actually, to port the symfony web debug toolbar as a Firebug extension. This will remove the toolbar from the page html and will show it in a convenient place that almost every web developer is used to.

Taking advantage from the cool new features of symfony 1.2 I started a project to develop a symfony plugin to send the data to the Firebug extension. The later has been smartly called FireSymfony.

Alvaro has another blog post that talks more about the first release.

With this release we continue to provide enterprise-grade features with our new Zend_Soap component, which brings PHP-style simplicity to building and exposing SOAP web services. This component can operate in both WSDL and non-WSDL mode and makes creating or consuming a SOAP service a snap.

Preview of Tooling Project:

Zend_Tool is a component currently under development in the Zend Framework library. It provides services for generating and managing ZF-based projects. We are offering a preview release along with ZF 1.6 to collect feedback from users in a variety of environments and with different requirements. Please let us know how Zend_Tool works for you by visiting the Zend_Tool focus group site at http://tech.groups.yahoo.com/group/zf-tool/. We will also be posting an overview of Zend_Tool on the Zend Developer Zone within the next 24 hours.

Lucene 2.3 Index File Format Support:

Starting with 1.6, ZF supports version 2.3 of Lucene's index file format. This update to the format allows segments to share a single set of doc store (vectors & stored fields) files, which enables faster indexing in certain cases. This also makes Zend_Search_Lucene compatible with the latest version of the Lucene project.

Zend_Session save handler for Database Tables:

This is a database independent adapter for use with Zend_Session. Saving sessions in the database may be used for supporting sessions which must be maintained across multiple servers or kept for logging purposes.

Paginator Component:

Zend_Paginator is a new component for displaying large data sets in groups of 'pages' on a website. It can paginate data from virtually any source, and it fetches data lazily to maximize performance and minimize memory use when the data set is particularly large (as is often the case with data stored in a relational database). Zend_Paginator comes with a few data source adapters out of the box, along with an interface for implementing additional data source adapters.

Figlet Support:

Zend_Text_Figlet can create large ascii-character-based text given a figlet font and a string to render. Although they’ve been around for a long time, Figlets are most useful for captchas nowadays, especially when a lightweight solution is required and/or bandwidth is constrained. In fact, the new captcha form element includes an adapter for figlets.

ReCaptcha Service:

ReCaptcha is a very cool service that provides text-based captcha images. The answers submitted to ReCaptcha help digitize printed books. The new captcha form element also includes an adapter for the ReCaptcha service. Read more about ReCaptcha here: http://recaptcha.net/learnmore.html.

Captcha Form Element:

A form element to render and validate captchas, which are commonly used to ensure a human is submitting a form and not a (potentially malicious) bot. The captcha form element is backed by several adapters for different captcha mechanisms, including GD-based graphics, figlets, and the ReCaptcha service. Users can implement their own adapters;each adapter takes care of validation and decorators to ensure the form element looks and behaves correctly, regardless of the captcha mechanism used.

Zend_Config_Xml Attribute Support:

XML attribute support has been added to Zend_Config_Xml that allows ZF developers to write smaller XML documents that are more human-readable. This attribute support is already seeing a lot of adoption inthe Zend_Tool project.

Zend_File_Transfer Component:

This is a new component used for transferring files from one machine to another over multiple protocols. It currently supports HTTP, with an adapter interface that can be implemented to support additional protocols in the future. This component also supports validation on the transferred file.

File Upload Form Element:

This component completes the HTML form element support in Zend_Form. Files can be chosen by the user, validated for properties such as size, and uploaded to the server simply by adding a file upload form element to your forms. The element utilizes Zend_File_Transfer internally to validate the uploaded file and move it to its final destination.

Zend_Wildfire Component with FireBug Log Writer:

Zend_Wildfire is a new component supporting the Wildfire protocol: http://www.wildfirehq.org/. This feature also adds a FireBug log writer to write server-side log events to a FireBug console. A specialized FireBug Zend_Db profiler is provided to log DB profiler data to the FireBug console, as well.

Media View Helpers (Flash, QuickTime, Object, and Page):

ZF 1.6 contains new view helpers for embedding Flash, QuickTime, Objects, and Pages in a view.

Zend_Translate adds the INI file format:

This addition adds to the long list of translation file formats it already supports.

What we see in the initial release is:

• JSON-RPC Server: We are re-working the Zend_Json_Server that has
  been in our incubator since, oh, what? 0.2.0? and never released to
  actually follow a specification:
  JSON-RPC. This
  will allow it to work seamlessly with Dojo, as well as other toolkits
  that have JSON-RPC client implementations. I have actually completed
  work on this, though the proposal is waiting to be approved; if you want
  to check it out, you can find it in the
  ZF svn.

  The original Zend_Json_Server implementation will be abandoned. It was
  never fully tested nor fully documented, which has prevented its
  release. Additionally, since it implemented its own ad-hoc standard, it
  did not provide the type of interoperability that a true JSON-RPC server
  implementation will provide. I am excited that we will finally be able
  to provide a standards-compliant solution for general availability.

  One final note: there are currently two different JSON-RPC
  specifications, 1.0 and 2.0. My goal is to support each, though for the
  time being, only version 1.0 will be supported, as that is the version
  Dojo currently targets.

• dojo() View Helper: Enabling Dojo for a page is not typically as
  trivial as just loading the dojo.js script -- you have a
  choice of loading it from the AOL CDN or a local path, and also may want
  or need to load additional dojo, dijit, or dojox modules, specify custom
  modules and paths, specify code to run at onLoad(), and
  specify stylesheets for decorating dijits. On top of this, this
  information may change from page to page, and may only be needed for
  a subset of pages. The dojo() view helper will act as a
  placeholder
  implementation, and facilitate all of the above tasks, as well as take
  care of rendering the necessary style and
  script elements in your page.
• Form Element implementations: One area that developers really
  leverage javascript and ajax toolkits is forms. In particular, many
  types of form input can benefit from advanced and rich user interfaces
  that only javascript can provide: calendar choosers, time selectors,
  etc. Additionally, many like to use client-side validation in order to
  provide instantaneous validation feedback to users (instead of requiring
  a round-trip to the server). We will be identifying a small group of
  form elements that we feel solve the most relevant use cases, and write
  Dojo-specific versions that can be utilized with Zend_Form.
  (One thing to note: Zend_Form's design already works very
  well with Dojo, allowing many widgets and client-side validations to be
  created by simply setting the appropriate element attributes.)
• dojo.data Compatibility: dojo.data defines a
  standard storage interface; services providing data in this format can
  then be consumed by a variety of Dojo facilities to provide highly
  flexible and dynamic content for your user interfaces. We will be
  building a component that will create dojo.data compatible payloads with
  which to respond to XmlHttpRequests; you will simply need to pass in the
  data, and provide metadata regarding it.

Of course, you can continue to any Ajax library in conjunction with the Zend Framework, and ditto for Dojo.... but why did this match happen?

There are many synergies and similarities between the two projects and their communities, including:

• Licensing and IP: Both projects are very business friendly.
• Design affinity: Similar philosophies, including a strong emphasis on use-at-will architecture.
• JSON format used strongly in both
• Comprehensive Ajax Solution: Dojo has it all
• Standards: "Dojo not only implements published standards, but also drives them"
• Communities and support: Strong communities, with support offerings behind them

And, here is some code from a JSON-RPC demo:

PHP-Ext

First, Sergei Walter Guerra told me about PHP-Ext "an open source widget library written for PHP 4 and 5 to empower the UI Layer."

The API looks like this:

ExtPHP

Then Chris Ravenscroft came to me to announce ExtPHP:

"It is something that I had to think about in my day job, because my team is migrating to PHP for web development and I believe that we simply do not have enough time for them to learn JavaScript's intricacies, I needed to be the one person who would have to wrestle JavaScript when problems happened. I therefore needed a way to insulate them from the gory details, which is why I created ExtPHP."

The API looks like this:

Maybe you guys can join forces? :)

Dirk Ginader blogged about a commenting trick (in German) that is one of these. He rightly claims that when you develop, you will comment and uncomment a lot as you optimise and test your code. This means either inserting lines with comment and deleting those lines, adding and deleting the /* */ by hand or using a shortcut of your editor of choice (I loved Homesite for ctrl+shift+m). In any case, it means highlighting several lines to comment in or out.

If you however use the following syntax then you only need to delete one slash to comment and uncomment a section:

The trick is the // before the closing */. With this you can just add another slash before the opening one and uncomment the block this way.

This works in many languages, alas not in CSS as there is no single line comment.

Update: in CSS you can just delete and add and remove an asterisk:

What is HTML Purifier?

HTML Purifier is a standards-compliant HTML filter library written in PHP. HTML Purifier will not only remove all malicious code (better known as XSS) with a thoroughly audited, secure yet permissive whitelist, it will also make sure your documents are standards compliant, something only achievable with a comprehensive knowledge of W3C's specifications.

What's new in 3.0?

Release 3.0.0 is the first release of 2008 and also HTML Purifier's first
PHP 5 only release.
The 2.1 series will still
be supported for bug and security fixes,
but will not get new features. This release a number of
improvements in CSS handling, including the filter
HTMLPurifier_Filter_ExtractStyleBlocks which integrates
HTML Purifier with
CSSTidy for cleaning style sheets
(see the source code file for more information on usage), contains
experimental support for
proprietary CSS properties with %CSS.Proprietary, case-insensitive
CSS properties, and more lenient hexadecimal color codes. Also, all code
has been upgraded to full PHP 5 and is
E_STRICT clean for all versions of PHP 5 (including the
5.0 series, which previously had parse-time errors).

You can run a live demo to see it at work.

The Simplicity PHP Application Framework is an advanced, scalable and extensible PHP application framework to aid developers in creating high traffic, high availability Web 2.0 online applications. Integrating a solid MVC framework with some of the best Open Source projects around Simplicity aims to assist developers with any amount of experience in taking their applications to a new level.

You can get to the code on the launchpad for the framework.

One important piece is the Ajax admin console, developed in Ext that allows a developer will be able to configure all aspects of their application via the Ajax interface, this includes database modeling and the creation of stub controllers, and even the addition of predefined actions to speed up development.

The article goes into detail on creating a form based data entry application that works offline. This means that entries are batched up, so when the user goes online they can be sync'd up. The forms are sent using Prototype and Ajax.Updater.

Jack iterates on the data model, going from a simple blog, to separate content.

Conclusion

For years now, web applications have been stuck at the 90 percent solution mark. Web applications are incredibly easy to develop, but fail utterly when the customer isn't connected to the Web. On the day Google Gears was released, I knew that this status quo had instantly changed. Just as the addition of Ajax functionality to the browser was the one small step that added rich interactivity, this small step of Gears solves one of the few remaining problems of web development. What a powerful tool indeed!

J4P5 uses a modified version of the CFG parser of the MetaPHP project, and is licensed under the GPL

This project is new. The current version already exposes most of the features commonly associated with JavaScript, such as objects, prototypes, closures.

Notable caveats of this version (aka "the TODO list"):

• No support for unicode strings
• No support for regular expressions
• Semi-colons at the end of statements are not optional
• Most of the pre-defined objects/methods have not been tested
• The speed is definitely slower than PHP. It's getting better though.

The designer works by simply using HTML in any way they wish, and then the programmer:

• Write selectors based on HTML structure
• Pass those selectors and Controller data to plainTemplate
• plainTemplate parses template, removing designer's example data
• If there is a need, you can manually write template proccessing rules with phpQuery - a jQuery port to PHP
• Everything caches to pure, human-readable PHP file, similar to that one written with no template engine
• From one HTML file You can build several templates
• Once the Designer updates the file, the cached template updates itself transparently

phpQuery is a port of jQuery that let's you do things like this:

Download plainTemplate