Our home setup is a little odd – the office is at the back of the building – almost as far away from the incoming ADSL connection as you can get. We have a Wireless N bridge between the 2 rooms – it’s a little temperamental but generally works. We have a plethora of wifi networks around us and it’s sometimes hard to find a clear channel without too much interference – so I’d assumed that the connection speed I was getting in the office was related.

More recently I’ve been able to do some proper testing of our setup and to my surprise I found that the local network was running fine. Not great but easily getting transfers of 5-10MB.

So I picked up the phone and called the usually helpful tech support of Jazztel to get some help with getting the issue fixed.

ADSL depends a lot on the distance you are from the exchange – so reaching the 20MB service we were paying for was unlikely but we were getting an avg transfer speed of 110 KBps – easily under 1MB so something was up.

Jazztel tech support has changed a lot – often the case as a company grows – and it’s not changed for the better. The first person we managed to reach was polite, helpful and quickly found that our line speed has been capped at 1MB even though their system reports that we should be getting the 20MB service. Ok – cool – so now we know it’s not an ADSL technical issue – it’s config related. Unfortunately he didn’t know how to get the cap removed – no worries he says – he’s passed it up the management food chain and we’ll get a call back the next day.

Days come & go without a call – so we call back. The experience this time however is worse – we reach an aggressive tech that tells us there is no problem and what we have is the best we’ll get. When I explain that we’ve been told otherwise and he needs to look more closely – he hangs up the phone and we end up talking to Customer Service and end-up with the usual tech support/customer-service ping-pong.

Yes there’s an issue but we don’t know how to fix it – if you’d like it fixed then you need to call tech support. Tech Support tell put you through to Customer Service – Huh!?!?

Some of the tech support can see the issue, others can’t be bothered enough to look past the automated tele-script their call center has to help.

The fact that there’s a cap on the line can be seen – and the cap is 5% of the service that’s being paid for. The actual bandwidth we’re getting is 10% less – so even though they’re happy to take your cash for a 20MB service, they’re delivering 0.5% of it.

Now it might just be a technical blunder – some config was written badly and it’s choked the line but the concern is that they don’t know how to fix it. Their system apparently doesn’t let them change the cap that’s been applied. This is worrying – as it means that management has prevented their techs from making the required change.

And if it’s a restriction put in by management – then in my mind it’s a management decision then it’s policy – which means deception & theft.

It’s a shame – they’re a young company that showed really great potential for delivering not only a decent service – but had a great ethic towards their approach to working with customers. Originally they provided a decent service for a good price without shafting customer-care, tech support or all of the other customer-oriented frills that makes a good service.

ISP’s often hide behind the ADSL “distance from exchange” statement to explain the connection speed – but this is the first time I’ve encountered masked management driven caps on the service beyond the usual Acceptable Usage Policies.

We’ve a few out and available now – most are ready for use – a few are still in beta.

The modules available for Android are:

Paypal (Mobile payments) – http://github.com/dasher/titanium_mobile/tree/integration-paypal

UrbanAirship (Push notifications) – http://github.com/dasher/titanium_mobile/tree/integration-airship

AdMob & Smaata (Mobile ads) – http://github.com/dasher/titanium_mobile/tree/integration-ads

Google Maps (overlays & Polygons) – http://github.com/dasher/titanium_mobile/tree/master-integration

A pull request has been done to Appcelerator for integration with Titanium – so with luck they’ll appear in mainline sometime soon

Her passion, insight & entrepreneurial spirit completes the foundation needed to deliver a truly exceptional product.

What

Essentially if you have an idea but want some direction about how to achieve it – drop me a line & we’ll chat.
I’ll help you understand the how & why, suggest open-source approaches to achieving it – so you can walk away and then engage with developers to make it happen.

Why

I love solving problems, I love technology and I’d like to help people achieve their ideas.
I’m a founder of a startup also – so I know what it’s like to be lost at sea and you just need a little help in understanding how to bring your idea to life. Technology wise I’m an enabler – just don’t ask me about marketing

How

You can discover my experience here – http://es.linkedin.com/in/davidashwood - and either contact me via linkedIn  or mail to david [at] CrucialDivide.com

If you want to bring an NDA then you’re welcome to. I’m only interested in listening to your idea and to discuss the technical how & why.

You can however, pay for the coffee

It provides a vehicle for asking questions but also provides an approach to determining the relevance of information within the available context.  The term available context was used as it’s often interesting to limit the available information to cognitive processes.

You often ask questions about statements you encounter: Who, What, Where, When, Why

You’ll also have an operational mode that you’ll switch between: operational modes help to define how a cognitive process should approach the problem.

In the human model – think along the lines of how your state of mind changes based on the situational aspects of the encounter.  The context of the situation can be external, reflective or constructed.

External contexts are where we are expected to respond – maybe not to all input – but to some.  Often these situations are where an action or consensus is required.
Reflective contexts are where information is absorbed and processed – generally to bring out understanding or knowledge but also when a pattern is reverse fit – not proving a fact but re-assimilating input so that it correlates.
Constructed contexts are the what if situations & problem solving. Similar to the reflective context but more about adjusting previous input to test fitness to something new while attempting to maintain it’s validity to other knowledge.

You’ll often start in a reflective context as you assimilate information and then move into a constructed context to maximise knowledge domains.  Then you’ll often edge into the external context – while running reflective contexts in the background.  Periodically you’ll create constructed contexts to boot-strap knowledge domains and to learn from how knowledge domains are created (which in turn will tune how the reflective domains obtain information).

Essentially this is a lot of talk for saying that you don’t always need to provide an output. 

Now I mentioned at the beginning that it’s often interesting to limit the information available to an available context – often it’s not only interesting but also important.  The available context is the set of prior knowledge (and the rules (or the approach) of applying the relationships to the information the it’s surrounding knowledge).

If all knowledge is available to an available context and the same approach is used for processing that information – then it’s hard for a system to determine relevance or importance of which facts to extract from data.  In essence the system can’t see the wood from the trees.

Think about how you tackle a problem you encounter – you start with one approach based on your experience (so you’re selecting and limiting the tools you’re going to apply to deal with the situation) and based on how the interaction with the situation goes – you’ll adjust.  Sometimes you’ll find that you adjust to something very basic (keep it simple stupid or one step at a time) – at others you’ll employ more complex toolsets.

The Eliza approach can be used not just as a processing engine – but also as a way of allowing cognitive systems to switch or activate the contexts I mentioned earlier.  It’s also a handy pre-parser for input into SOAR.

One of the reasons for these recent posts is after visiting zbr’s site and reading his interest in NLP and cognition.  I stumbled over his site when looking to understand more about POHMELFS, Elliptics and your DST implementation.  I’ve been looking for a paralleled distributed storage mechanism that is fast and supports a decent approach to versioning for a while for a NLP & MT approach.  Distribution and parallelism are required as I implement a virtualised agent approach which allow me to run modified instances of knowledge domains and/or rules to create dynamic contexts.  Versioning is important as it allows working with information from earlier time periods, replaying the formation of rules and assumptions and greatly helps to roll-back processing should the current decision tree appear fruitless.  In human cognitive terms these act as sub-concious processing domains.

The primary issue is due to perception where too much emphasis is attributes to the human senses (primarily sight and sound) – which as I’ve mentioned before – are just inputs.  As you’ll know from physics – you’ll often see simple patterns repeated in many different fields – it’s unlikely that cognitive processes will be any different when dealing with sound/sight and thought.

The next issue is that many fall foul of attempting to describe the system in terms they can understand – a natural approach but essentially it boils down to the pushing of grammar parsers and hand lexers with too much forward weighting to identify external grammar (essentially pre-weighting the lexers with formal grammar).  An approach that can produce interesting results but isn’t cognition and fails as an end game for achieving it.  Essentially this is the approach used in current machine translation processes in it’s various forms.

The key fundamental issue is much simpler and related to issues around:  pattern, reduction & relationship.  An area that had some activity a while ago in various forms (cellular networks, etc) but fell to the wayside generally due to poor conceptual reference frameworks and the over-emphasis on modelling approaches used in nature (neural networks).

Now comes the time of definitions – a vehicle to ensure we’re on the same page

Pattern:
Cognitive processes thrive on them – and it’s one of the main drivers behind how it perceives, processes and responds to information.  There’s a constant search to find similarities between what is perceived and what is known.  It’s a fuzzy matching system that is rewarded, in the sense that it promotes change or adaptation, as much by differences as it is with finding similarities.  When thinking about similarities – a handy term is to think about something being true or false.  Don’t confuse true/false as the general definitions of the terms – it’s more about the sense of confidence.  If something has a high confidence of being valid then it is true.  The threshold of confidence is something that evolves and adapts within the cognition over time (essentially as a result of experience).
The development of patterns is both external (due to an external perception or input) and internal.  To avoid turning this comment into something massive (and boring you ) – think along the lines of the human cognitive process and the subconscious or dreams.

Reduction:
Reduction happens at several key stages -  essentially it’s when a domain of experience breaches a threshold.  It’s a way of reducing the processing required to a more automatic response.  Think along the lines of short-circuit expressions.  It’s a fundamental part of the cognitive process.  From a human cognitive perspective you have probably seen it in your climbing and in your learning of the trumpet.  We often express it as “having the knack” or “getting the hang” of something.
It’s important for 2 reasons: a) it means it has gained knowledge about a domain; b)  it allows the cognitive process to further explore a domain.  While Reduction is a desirable end-game – it is not The End from a cognitive process perspective.  The meta information for this node of Reduction combines again and again with Pattern and Relationship allowing the process to reuse both the knowledge itself but more importantly the lessons learned when achieving reduction.

Relationship:
Relationship is really a meta process for drawing together apparently unrelated information into something that’s cohesive and is likely to either help with identifying patterns or for bringing about Reduction.  Relationship at first looks very similar to Pattern but differs in it’s ability to ask itself “what if” and by being able to adjust things (facts, perception, knowledge, Pattern, Reduction and versions of these[versions are actually quite important]) to suit the avenue that it being explored.  When expressed in human cognitive terms think of Relationship as the subconscious, dreams or the unfolding of events in thought.  The unfolding of events is an example of versions.  Essentially Relationship is a simulation that allows the testing of something.

NLP based on a grammatical rules engine, while an interesting toy, is essentially a dead-end when it comes to developing an approach to cognition.  Language is a complex system that has evolved over time and continues to evolve each and every day.  Grammar is an artificial construct that we have developed as a vehicle to describe language but  describing something doesn’t mean you understand it or that it can be used to extract knowledge or understanding from what it attempts to describe.

Take the example from Cyc (http://www.cyc.com/cyc/technology/whatiscyc_dir/whatsincyc):
* Fred saw the plane flying over Zurich.
* Fred saw the mountains flying over Zurich.

Grammar itself will help develop a weighted tree of the sentences and you’ll be able to describe the scene – but the system will lack enough reference to be able to respond.  In such a situation what is the proper response?

To answer we need a reference model – which luckily we have all around us everyday – people.  What do people do when they encounter a phrase and don’t have enough information to process it?  They ask a question.  What question would they ask?  Who’s fred? What’s a plane?  What’s Zurich? or would they laugh out loud as they exclaim (and picture) the mountains flying? (in itself a valid hypothesis)

Knowledge is obtained from the answer to the question – as it provided an addendum – a relationship between the phrase, the question and the answer.  Additionally the question itself often gets corrected – providing a short-circuit feedback  loop to the knowledge acquisition process.  The description of the answer also provides information about the relationship of items in the phrase to other information stored within the system.

What’s Zurich?  Zurich is the name of a city in a country called Switzerland.

(assuming that there is some information about what a plane is or that there is some relationship that interprets plans as machines like a car)
What color is the planes? Planes are all shapes and colors but this plane is bright green.
(note in this example the question indicates the singular but uses the plural – which is corrected in the answer)

The question provides insight into the internal state of the system we are interacting with (be it a computer program, a child we’re reading a story to or a colleague we are interacting with).  Inherent in any interaction is feedback, correction, elucidation of terms and phrases to assist understanding with those we are interacting with.  Often it happens in a subconscious way and tends to be in the style of continuous correcting feedback (the same approach we use when we reach down to pick up an object off of a surface).

A system needs to adapt & correct, to provide feedback (both to itself and with the other party it is interacting with) in a way that’s more than just updating state – but that also affects the very rules that make up the system itself.  This, however, is where many people tend to start going wrong.  A common pitfall is that the rules are considered to be the weightings between nodes of information or its relationships.  This however means that the underlying reference system (often implemented as grammar rules) rarely changes – which in essence lobotomizes the system.  It’s an indicator that you’ve put too much forward knowledge into the system.

Take how children learn – not the mechanic but the approach that’s used and not just for language or understanding (which is what we are trying to replicate when we implement the system) but with everything they do.  Nature, bless her cotton socks, is frugal with how she expends energy – so she reuses as much as possible (in essence cutting things down to their most common denominator).  You’ll see the same approach being uses for walking, talking, breathing, looking and following objects – in everything that we see, do or think.  Over time the system specializes domains of knowledge – further compartmentalizing – but also reusing that which has been learned and found to be valid in the domain.  Which in turn allows for further specialization and compartmentalization.

The end result was a great fireworks show and the box melting, frying the cables and fusing the wires.  The end result being no telephone or internet for 80% of the community in this part of town.  The trunk for my street has just been laid and connected – so I’m back online and picking up mails at last.

Generally it’s a mechanism that allows you to control the configuration and software available on machine but it’s usually clunky, brutally inefficient on the network and generally requires total control of the target machines.

Then along comes Opscode and opens up their Configuration Management Kitchen with Chef.  Chef is a lightweight approach to Systems Integration & Configuration Management (SI & CM for the light-hearted) built on Ruby/Rails/Gems that allows you to quickly deploy and configure software and services without requiring total domination.

I’ve had my eye on it for a while and with the Virtual Machine environments I’ve been working on for Symfony and Zend – I decided to dig in and give it a spin and I’m impressed; almost beyond words.

Chef depends on having Fully Qualified Domain Names up and running and can be a little quirky without them.

The installation instructions for the Chef-Server and Chef-Client are clear and concise and can be found here.

You start by installing the Chef-Server which provides the core back-bone to support your environment.  Once it’s up and running you have Chef running on Rails under Apache providing a web and REST interface for clients (or nodes in the Chef parlance).  Here you can view and control the attributes of a node, examine your configuration scripts (Recipes)  and authorise clients.  The GUI tools in the current (6.2) release are a little raw but functional and the coming 6.4 Release sharpens up the Web UI a lot (and brings with it a whole host of exciting features).  I setup the chef server on a stand-alone VirtualBox machine with 256 MB memory and a 3GB disk – which is working well for everything I’ve thrown at it so far.  You’ll need to login to the Web UI using OpenID and ensure you use the appropriate domain appended to your login – full details of the OpenID providers and their naming schemes can be found on the OpenID site here.

It can take a few minutes for the registrations to appear in the Chef Web UI.

Once you have the server up and running you’ll need to install the chef-client on a host.  Once up and running the client will connect to the server and register itself.  You’ll need to fire-up the Web UI on the server and authorise the client before you’ll be able to do anything more with the client.

Once it’s been authorised just run the chef-client again with:

sudo chef-client

When it completes you’ll see the information about the client in the Web UI in the nodes and status panels.

If you don’t authorise a client on the server then you’ll see a HTTP 403 error when you run the chef-client.

Now you have both the client and server up and running – you can get down to the real business of deploying something.

Open 2 SSH connections – one on the chef-server and another on the chef-client and start simply by following their quick-start guide on the chef-server and in a couple of minutes you’ll have your first chef-recipe complete.  Now just drop into the cookbooks folder and copy the quick_start cookbook to /srv/chef/site-cookbooks:

cd cookbooks
cp –R ./quick_start /srv/chef/site-cookbooks/

Now refresh the Web UI and open the Recipes Panel and you’ll see the quick_start recipe that you just created listed.

To apply the recipe to a node (your client) open up the nodes panel in the Web UI and double click on Recipes for it.  In Chef 6.2 you’ll get an awful textbox with the information for the node in JSON format.  Scroll down to the bottom and you’ll find the recipes entry – inside the [] put “quick_start” (include the “”) and hit save.

The end result should look something like:

“recipes”: [
" quick_start"
],

If you did it right you’ll see the page update.  Another minor issue in the 6.2 release is that if you didn’t update the JSON correctly you’ll see saving that’ll never complete.

All that’s left is to switch to the chef-client SSH terminal and get the client to update itself now with:

sudo chef-client

A few seconds later the client will find that it has a new recipe and install it.  On the client go to the /tmp folder and you’ll see deep_thought.txt from the chef-run J

Now this seems like a lot of effort to get a text file to appear in a folder – but it’s just as simple writing a recipe that installs MySQL, PHP, Redmine, Symfony or Zend Server.  But it’s not just about installing packages that’s already pretty simple using bash with apt or yum.  Using a recipe allows you to ensure that the installs are idempotent or transactional.  If one part fails – then you can ensure that the machine is left in a known reliable state.  If you have a failure in a script then you can be left with partial installs or worse – the machine in an unreliable or unworkable state.

One of the exciting aspects to all of this is that it’s very easy to hook things together – not just on one machine but all machines in your environment – regardless of what OS they’re running.  A recipe to install Zend Server, Symfony, MySQL or as a single package will work on Ubuntu, Redhat, CentOS or most other variants.

Hooking into the infrastructure allows very simple approaches to things like provisioning, deployment and configuration of environments – in my case this allows:

• Automated creation of a virtual machine instance
• Automatic provisioning of the instance
• Dynamic allocation & changing of the resources available to the instance (Memory, Disk, Drives, etc) although with VirtualBox a reboot is needed for memory changes to take effect.
• Dynamic package and configuration – allowing me (from within the VM instance) to switch it’s mode of operation and determine its role.  So within minutes it changes from all in one (complete LAMP on the instance) to the DB Server role

Generally when developing you should have an environment that represents that to which you’ll be deploying to – it’ll save you time, effort and much pain to have something as close as possible.  There are however, several scenarios for developers:

Targeted deployment

Ideally your environment matches that to which you’ll be deploying to. If you control the server infrastructure then this is less of a problem – you’ll build the server yourself (ideally via an automated deployment process) and building a VM from this is trivial.

If you don’t however control the server infrastructure then you have a more complex situation to deal with. If the gods are smiling then they’ve built their server completely from public distros and repos and used a package manager for all installs. If this is the case you can dump the package list and server build – and rebase an image yourself. Often however they have a custom OS build (tweaked for whatever reason), local repositories (hopefully mirrored) but sometimes not and a few extras thrown in. This makes building an image that represents the environment you’re going to use, while not impossible, generally non-trivial.

ServerGrove (http://www.servergrove.com/), forward-thinking & proactive, are interested in providing an image to their customers that does just this – allows people to develop locally in an environment that represents where the application will be deployed.

Trends

A growing trend with hosting providers is where they allow you to upload your own image to the hosting environment allowing you to build your own OS (subject of course to licensing requirements). One of the aims of the VM was to provide a way for devs to start locally and then upload a copy of the image to the hosting environment. With a few caveats (mostly around networking) you’re assured of 100% success for the deployed project as you’ve been able to put it through its paces in before uploading.

Non-Targeted Deployment

In this scenario the developer is building applications for non-specified specified servers – either because they don’t have or haven’t selected the hosting environment yet, they don’t have complete information from the project sponsor – or some other reason (it’s weird and wacky out there). Another possible deployment is Open Source projects where the deployed application may be any OS – and yet you’d like to have a common “known” environment for developers and end-users.

In this situation the VM helps both the developer and the project sponsor – as it’ll allow the dev to share the VM with the sponsor for testing and signoff. Essentially passing the monkey wrt the hosting environment.

General Approach (now and 1.x)

The current approach I’ve taken is mainly aimed at providing a lean-learning curve, a clean & repeatable environment to the community developing against Symfony and the Zend Framework (the Zend side is mostly a freebie but also aimed at helping people with Lucene search issues). With each build I test to ensure that all sf frameworks work by deploying a test application that covers ORM’s, plugins, routing and the DB/httpd. With the build I try to ensure that it’s portable and therefore works against the major VM Client vendors (VirtualBox, VMWare and Xen currently). The aim of the 1.0 release is to have something built and packaged ready to run – much like the sf sandbox currently works.

While VM’s have been around for a while – and while installing linux has become more user friendly – there’s still a lot of areas you can trip-up building images and installing OS’s. One of the aims was to remove this as a blocker to devs wanting to just get down to developing applications.

With the release of 1.0 there should be the following images and deployments available:

· Images

o devSFCoreServer

o devSFCoreIDE

· Deployments

o Stand alone (everything in one box for simple dev projects)

o Load Balanced (built using devSFCore with configuration that puts the server into modes: lb [load balanced], web [web server, memcached & no db], db [db, svn, no httpd but a http management interface])

· Project helpers

o Helpers to aid start-up of projects and development. Things like building the root development folder, linking to the version of the framework you wish to use, creating and configuring the DB, configuring the application to use the DB and running tests on the initial setup. Think a2ensite for creating a symfony application and you’ll get the picture. The intention isn’t so much to dumb down – but to streamline and to facilitate adoption by those not that familiar with symfony. Included will be log creation of the actual steps involved to help devs understand what to do.

With Deployments the general idea is that you’ll be able to run multiple images in modes – to facilitate testing, architecture scenarios, etc. With this you run one image as a DB, several as web servers and drop in a load balancer – and hey-presto you have a way to test how your application performs when scaling out.

With the 1.x branch I’m intending to go with a much lighter approach – still with some base images for various distributions and deployments (there will be standard and live images along the same approach as the live-cd used with some distributions) but using some of the approaches you’ve outlined for providing the packages and for linking in with repositories. This approach however requires some infrastructure to support it – and infrastructure = time + resources and resources = money.

This approach essentially extends the current sf sandbox to a deployed image mode. It’ll work out compatibilities, issues and fixes, deal with things like pear and pecl dependencies, PDO and handle the deployments you’ll see above.

With 1.x comes features for both devs and hosters (and allows for Targeted deployment). Hosters can build their base image and include the needed components into the image – and share it with their customers(the devs). Devs can download and use the image – and it’ll pull all the needed parts down. When they are ready to deploy – then from within the VM they can provision and deploy the application. With the provisioning on the hosting provider side building the image locally, deploying it and then accepting the deployment of the application.

Should the dev decide to move hosting providers to another supporting this model – as it’ll be built using the same components (but probably a different base OS) – then it should be a simple process to download their base image, deploy from the current VM to the new VM, test and redeploy.

Posted via web from Dasher’s Dev Den

One of the great things about the VirtualBox client is that it supports headless virtual machine and implements an RDP interface to them.  Allowing you to easily connect & control it from both Windows and *nix.

Just point the RDP client to the IP Address of VM Host & using the port displayed – you essentially have a console connection to it.  There’s some handy extras like clipboard and folder sharing, private networks and dynamic virtual HD’s.

Posted via web from Dasher’s Dev Den

The website contains all the details about the what, where and how and there will be some followup articles on my blog in the next couple of days.  If you find any issues with the image – then the Project Management URL is on the site.

Posted via web from Dasher’s Dev Den

Fabian presenting the freshly hatched stand alone components for PHP (I’m still wondering what he’s hiding behind his back )

Posted via web from Dasher’s Dev Den

You can generally create your own version of any class – if you put the new version in the right place and if the file and class are named properly.
The location you put the file depends on a number of factors (is it a core module or a plugin) and the scope you want to affect.

With plugins generally the best approach to start is to be as local to your Symfony app as possible.

1. Clear your cache – it doesn’t hurt to do this before and after you start making changes and it’s a good habit to do this often
2. Start by making a folder for the in apps\<applicationName>\modules\<pluginName> (often you just make the folder rather than using the generator)
   • Depending on what you’re overloading you create the sub folder here for it – so if you’re modifying a template then create a templates folder under the plugin folder you just created
3. Now copy the existing file from the plugin to the folder you just created- it’ll be a good starting place to making any changes.  When copying a file it’s the file that will be used initially by the autoloader  rather than a file named Base….
   • So if you’re looking to override the actions for sfGuard, it’s going to be under the sfGuard\modules\sfGuardUser\actions\actions.class.php
   • Well written plugins will use a base file – for sfGuard this is BasesfGuardUserActions.class.php – which allows easy overriding of your own functionality – you’ll see a reference to this in the top of the actions file
   • You’ll need to change the require/require_once statement in the top of the file you just copied – to point to the correct place as when you override the autoloader won’t be able to find the class you’re trying to include.
   • This file will generally just be a placeholder – with all the work being done in the parent class.  You’ll need to refer to the base class or have a decent IDE that gives you code assist or exploring of the methods in the parent to determine what method signatures are available for you
4. Now you can implement your own functionality in the file – for an action start with something simple like overriding a method and putting die(“hey – it worked! – Who’s da man?!?!”).  You can even put this just under the require statement to test – so you’ll know that it was your customised file that was included rather than the specific one within the plugin itself.
5. Clear your cache again and fire up your browser to load a page under the application you used above
6. Now you see your die statement is being hit – you can implement the actual code you want to happen

The locations available for you to put custom classes are:

• project\apps\thisApp\modules\moduleName\folderType\fileName
• project\apps\thisApp\lib\folderType\fileName
• project\apps\thisApp\lib\fileName
• project\lib\folderType\fileName
• project\lib\fileName

Where:

thisApp is your application name
moduleName is the name of your module or the plugin name
folderType is the type of folder – i.e. actions, templates, model, etc
fileName is the name of the file in the expected format (so actions.class.php for the actions class)

Posted via web from Dasher’s Dev Den

I needed to install memcache on windows to help see if I could reproduce a problem on the Symfony forums.

Posted via web from Dasher’s Dev Den

The PHP JS lib has been put into PECL which, with the coming release of PHP 5.3 will finally allow some interesting scenarios – especially when it comes to testing. It should be possible to extend the Symfony Web tester to include the JS behaviours, Ajax in test cases and a whole lot more!
tag: synfony, Server side JS

Posted via web from Dasher’s Dev Den

There’s a couple of tools available that make the dev’s life easier:

• Firefox + Firebug
• Desktop Proxy (Fiddler)

The winning combo of Firefox + Firebug allow you to see what’s on the page, inspect your form + input tags and work out if there are problems locating page assets (like css, images and JS).  Just right click on any of the page elements and select “Inspect Element” and you can navigate the HTML in a quick and intuitive way.  Enable the Script, Net & Console for the site by clicking on the headings from within Firebug and you’ll be given access to those features and you can examine which assets are missing, load times, set breakpoints on your script – all in realtime and on the fly.

Watching the Firebug net panel – you’ll see details of HTTP GET’s, POST’s and AJAX requests but sometimes it misses a few things – especially when you’re using Flash or Flex on the page – which uses connections outside of the browser and therefore not tracked by Firebug.

firebug net panel

In this case you’ll need to use a desktop proxy to monitor the connection which can proxy all connections and will allow you to inspect & decode the traffic.  Fiddler is a lightweight desktop proxy for the Windows Platform that does just this and more.  You can capture, review, decode, replay and construct all connections – drilling into and examining what’s happening and thereby giving you a much clearer picture about what’s happening between the browser and the server.

Posted via web from Dasher’s Dev Den

Posted via web from Dasher’s Dev Den

I’ve used ipvs (http://www.linuxvirtualserver.org/software/ipvs.html) effectively on a few sites for clients - it’s more scalable than using reverse proxies.

It’s a handy & fast and efficient way to:

· load balance

· manage traffic to the cluster (allowing for transparently bringing servers online/offline, migrations)

· firewall the cluster and back-end services

I’m not a fan of moving the ORM layer – in terms of bang/buck it’s just not efficient or cost effective.

Logical separation is more important that physical separation.  It’s enough to use a dedicated db server and optimise the machine for the purpose.

One of the hardest problems is dealing with assets in dynamic sites – images, movies, etc – when you have multiple servers.

Shared file systems (ie NFS) just doesn’t cut it. For a couple of clients I’ve used libs built on fuse but OS support can be patchy.

The handy thing about fuse is that you can use it fairly easily in conjunction with CDN’s but planning the financials is complex – and it’s something you need to consider in your architecture.

Fuse in local mode is easy to setup, scalable, fault tolerant and fast – most hosting providers have gigabit local network connections (and local network traffic isn’t billable). There’s a couple of hosting providers that implement local CDN’s which they make available for clients – but these are few and far between.

Most projects I tend to recommend the VPS route rather than dedicated machines. It’s cost effective, allows for growth, machines can be provisioned in minutes rather than days and you can respond quickly if traffic increases. Allocating/de-allocating extra resources is usually just a few clicks away and if you start exceeding your optimal utilisation you can provision another machine, hot tweak the IPVS table and you suddenly have another machine serving your users. Good hosting providers even have API’s that allow your application to adjust its resources up/down from within the app.  If it’s a short term spike (due to a promotion, press, etc) then when things calm down a few days later – you can hot tweak the ipvs table, un-provision the machine and hey presto – you’ve only incurred costs for the duration. Implementing this type of approach means you need to understand when it’s best to scale up and when you scale out – and it’s hard to determine what strategy to take until you have optimised your environment and have accurate metrics about how your application performs.  With this you can set thresholds and with monitoring in-place the application can notify you when these are exceeded.

Posted via email from Dasher’s Dev Den

Develop apps with the Aptana IDE and deploy from within the IDE directly to the Aptana cloud. Supports SVN, Staging and live – very handy and very cool.

Posted via web from Dasher’s Dev Den