Tricode biedt vanuit Skopje, Macedonië software ontwikkeling en applicatiemanagement op maat.

Pance Gasteovski is field manager van het Tricode kantoor in Skopje. Hij is verantwoordelijk voor alle operationele zaken en dagelijks bezig met het motiveren en coachen van zijn mensen.

“Nearshoring in combinatie met Agile heeft meer voordelen dan alleen kostenbesparing. Scrum motiveert mensen hun kijk op projecten te geven. En nieuwe inzichten uit een andere cultuur zorgen voor een frisse kijk op software ontwikkeling.”

Over nearshoring en Macedonië

Wij geven klanten het gevoel dat zij ‘gewoon’ met een bedrijf in Nederland te maken hebben. De kwaliteit is even hoog en afstand is geen issue. Daarom investeert Tricode veel in communicatie, opleiding en de sociale vaardigheden van onze Macedonische collega’s. Pance: “De motivatie van het team in Skopje is bijzonder hoog. Dat zie je écht terug in het resultaat.”

Werken met Agile op verschillende locaties (distributed Scrum)

Ook in Macedonië werk Tricode met Agile. Dit vraagt elke dag om heldere projectdoelen voor elk teamlid, op elke locatie. Pance: “We werken met moderne communicatiemiddelen, zoals video conferencing. Overleggen gaat immers veel beter als je elkaar in de ogen kijkt. En we hebben een uitwisselingsprogramma gelanceerd. Collega’s uit Macedonië werken een aantal weken in Nederland en andersom. Door te praten over Agile, Scrum en software ontwikkeling begrijpen collega’s uit andere culturen elkaar beter. En zij bouwen meteen aan een goede werkrelatie”.

De passie van Pance

Pance: “De combinatie van mens en techniek is het leukste van mijn werk. Deze passie zie je ook terug in mijn opleidingen. Naast mijn master in IT software development volgde ik een studie MBA Management. Ik wil elke dag het beste uit onze mensen halen. Zowel op persoonlijk als op technisch vlak. Als dat lukt ben ik een gelukkig mens.”

Lees alle verhalen van Tricode medewerkers >>

Pance over nearshoring vanuit Skopje - Tricode

“Tricode werkt met scrum, een methode om software in teamverband te ontwikkelen. Twee mensen van ING waren vast onderdeel van het projectteam. De intensieve samenwerking zorgde voor korte lijnen, snelle beslissingen en een effectieve aanpak van test en oplevering.”

De rol van Dennis & Sander bij het project voor ING

Sander en Dennis zijn allebei als developer bij het ING-project betrokken. Ze werkten mee aan de ontwikkeling van een serviceportaal voor intermediairs op basis van het content management systeem Adobe CQ5.

Sander is specialist in webapplicaties en weet alles van Java en PHP. Dennis heeft allround ontwikkelervaring. Naast Dennis en Sander bestond het ING-team van Tricode uit twee frontend developers en een scrum master.

De uitdagingen

Sander: “De krappe deadline van het project vroeg om een slimme werkwijze. We hebben gebruikgemaakt van handige tools om het ontwikkelproces te versnellen. Denk aan automatische installaties op de server en intelligente software waarmee we de status van het ontwikkelproces constant in de gaten hielden. En door scrum te gebruiken konden we elke drie weken een nieuwe versie van het product opleveren en meteen demonstreren aan onze teamgenoten van ING.”

En terugkijkend?

Beide jongens zijn tevreden over het resultaat. Dennis: “Er staat een uitstekend platform gebaseerd op het vooruitstrevende CMS Adobe CQ5. En ING is tevreden, daar doen we het voor.”

Lees alle verhalen van Tricode medewerkers >>

Developers Dennis & Sander over scrum en Adobe CQ5 - Tricode

Om fondsen te werven verkoopt Rigas met diverse kleuren beschilderde schelpen. Elke schelp, in totaal zijn er 1.000 stuks, is uniek genummerd en vertegenwoordigt een lotnummer. Na de tocht met Vélo Afrique ontvangt de persoon met het winnende lotnummer, het meest interessante voorwerp dat Rigas tijdens zijn tocht door Senegal heeft gezien en meegenomen.

Tricode steunt het initiatief van Rigas en heeft een schelp bij hem gekocht. Ook dit initiatief steunen? Surf naar Velo Afrique om meer te lezen over dit initiatief.

Tricode steunt “Velo Afrique” - Tricode

“Mobile is mijn passie. Ik vind het geweldig om elke dag met de nieuwste technieken op het gebied van mobiel internet te werken. Gelukkig kan ik bij Tricode mijn hart ophalen. Innovatie staat bij ons voorop.”

De rol van René bij het project RIVM

René is als webdeveloper betrokken bij de bouw van de mobiele applicatie (app) voor het RIVM. Doel van de app: alle actuele ziektebeelden en diagnosen inzichtelijk maken voor medici.

De uitdagingen

We moesten een grote hoeveelheid complexe informatie op een gebruiksvriendelijke manier in een crossplatform mobiele applicatie presenteren. Hoe maak je die vertaalslag? En welke tools en technieken zorgen voor het beste resultaat? René: “Het is erg uitdagend om de beste oplossing voor ingewikkelde online vraagstukken te bedenken. Ik volg altijd de laatste ontwikkelingen in mijn vakgebied. Onze klanten waarderen dat extra stukje expertise. En mij geeft het veel energie!”

Over René

René is webdeveloper bij Tricode. Hij is elke dag bezig met het ontwikkelen van internettoepassingen, ook in zijn vrije tijd. René: “Tricode is toonaangevend op het gebied van webbased software ontwikkeling. We willen constant innoveren én de beste zijn. Precies ook mijn persoonlijke drijfveren”.

Lees alle verhalen van Tricode medewerkers >>

Webdeveloper René Pot over mobiele applicaties - Tricode

Dankzij de initiatieven van Bedrijvenkring Veenendaal en Promotie Veenendaal, hebben Bemet International en Tricode Professional Services elkaar leren kennen.

Op de de eerste ICT-netwerkborrel, een regelmatig terugkerende netwerkbijeenkomst voor ICT-bedrijven in Veenendaal, werd het eerste contact tussen beiden gelegd en bleek dat beide bedrijven wat voor elkaar kunnen betekenen. Het eerste succes van Veenendaal ICT is daarmee een feit.

Bemet is softwareleverancier voor de maakindustrie en levert CAD/CAM, ERP en APM softwareoplossingen aan meer dan 800 bedrijven in binnen- en buitenland. Bemet ondersteunt bedrijven in het complete proces van offerteaanvraag tot en met de factuur.

Tricode ontwikkelt maatwerk software en levert ICT diensten, zoals het ontwerpen en realiseren van e-commerce sites, schaalbare software, mobiele applicaties en SaaS. Ook houdt het bedrijf zich bezig met het realiseren van applicatievirtualisatie, extreme performance en systeemintegratie. De doelstelling van Tricode is bedrijven efficiënter te laten werken om zo klanten beter van dienst te kunnen zijn. Ook Bemet zal in de toekomst nog efficiënter gaan werken door de samenwerking met Tricode.

De samenwerking

Bemet is ontwikkelaar en leverancier van de ERP-oplossing Plan-de-CAMpagne. Deze ERP-oplossing is momenteel toegankelijk via verschillende webtoepassingen. Bemet wil deze mogelijkheden verder uitbreiden en Plan-de-CAMpagne via nog meer applicaties beschikbaar stellen. Tricode zal Bemet in dit proces ondersteunen door het ter beschikking stellen van de meest efficiënte tools en technieken, zodat steeds meer informatie toegankelijk wordt via websites, smartphones, mobiele telefoons (webapps), scripting, slimme handterminals en externe pakketten.

Naast het breder toegankelijk maken van Plan-de-CAMpagne, begeleidt Tricode Bemet bij het moderner en efficiënter inrichten van de ontwikkeling. Tricode stelt hiervoor nieuwe tools en nieuwe technieken beschikbaar. Hierdoor zal Bemet beter gaan testen, beter gaan ontwikkelen en betere codes verkrijgen. Bemet zal zo nog efficiënter en effectiever gaan werken. En beter en sneller inspringen op de wensen van de klant.

Zowel Bemet als Tricode verheugt zich op de samenwerking. Anton van Zeijst, directeur van Bemet International, is van mening dat de overeenkomst tussen Bemet en Tricode het voorbeeld is dat het organiseren van ICT-netwerkbijeenkomsten in Veenendaal loont. ,,Het bezoeken van de ICT-netwerkbijeenkomsten zorgt ervoor dat ICT-bedrijven elkaar op een vrijblijvende manier beter leren kennen, relaties kunnen worden opgebouwd en een relevante bijdrage wordt geleverd aan de promotie en ontwikkeling van Veenendaal als ICT-stad”, aldus Van Zeijst.

Niels Donninger, sales accountmanager van Tricode, deelt deze mening en stelt: ,,Door het bezoeken van de ICT-netwerkbijeenkomst krijgen Veenendaalse bedrijven inzicht in de ICT-mogelijkheden die aanwezig zijn in Veenendaal. Bedrijven worden zo bewust van de mogelijkheden die de eigen stad biedt. Oplossingen zijn vaak dichter bij huis te vinden dan men in eerste instantie denkt. Dit komt ook de locale economie van Veenendaal ten goede.”

Voor meer informatie over Bemet International kan contact worden opgenomen met Bemet via tel. 0318-495858 of via marketing@bemet.nl . Geïnteresseerden die meer willen weten over Tricode, kunnen contact opnemen met Tricode via tel. 0318-559210 of via info@tricode.nl.

Bron: De Veenendaalse krant, 13-11-2011

Eerste succes Veenendaal ICT een feit – Tricode en Bemet - Tricode

Mobiele telefoon,GPS- ontvanger, regenjassen en een bootje; alle ingredienten voor een uitdagende sloepengame.

Ook dit jaar zijn we er met alle collega’s en partners op uit getrokken voor een actief en gezellig weekend. Net als vorig jaar had de bestemming met water te maken, geen zee dit jaar, maar wel de Loosdrechtse Plassen.

Tegen lunchtijd verzamelden we met z’n allen bij het hotel. Na een lunch in het hotel werden we in groepen verdeeld. Met een GPS-ontvanger en mobiele telefoon werden alle groepen op pad gestuurd voor een GPS- tocht op de Loosdrechtse Plassen. Aan de hand van GPS-coördinaten werden de Loosdrechtse Plassen bevaren. Met het juist beantwoorden van vragen en opdrachten die we onderweg tegenkwamen konden nieuwe GPS- coördinaten ontcijferd en punten verdiend worden.

Via de mobiele telefoon kon de stand in de gaten gehouden worden en moesten foto’s gemaakt worden die later op de dag vertoond zouden worden. Na zo’n twee en een half uur, een ietwat bewolkte lucht en hier en daar een doorweekte collega kwamen toch alle bootjes weer op tijd terug in de haven.

Het was inmiddels al tegen het einde van de middag en nadat iedereen weer was opgefrist en opgewarmd van een beker warme chocolademelk liepen we met elkaar naar de nabijgelegen brasserie Het Kompas. Na een welkomstdrankje was het tijd voor de de prijsuitreiking. Hier werd bekend dat het team ‘Das Boot’ de winnaar was van de sloepengame! Zij hadden de meeste vragen goed beantwoord en waren als een van de snelsten terug in de haven. Zoals het hoort werden de medailles omgehangen en was het tijd voor de Barbecue. Het weer zat niet mee, dus alles stond al netjes gebakken en gebraden voor ons klaar. De sfeer zat er goed in en de feestavond kon beginnen.

De DJ draaide muziek en al snel gingen de voeten van de vloer. Ook de casinotafels waren weer present, waar menigeen een potje blackjack of roulette speelde.

Rond middernacht, toen iedereen wat drankjes en nog wat drankjes en soms nog een drankje op had ging iedereen hotelwaarts. Het was een lange en gezellige dag geweest en de volgende ochtend bij het ontbijt heerste dan ook een serene rust. Het was weer een erg gezellig weekend geweest en iedereen ging voldaan richting huis om nog even rustig aan te doen om de volgende dag weer uitgerust op het werk te verschijnen!

Sloepengame – Bedrijfsuitje 2011 - Tricode

Being able to process large amounts of data becomes increasingly important for an increasing number of people and organizations. Processing data could mean a variety of things and differs per case. However in the most basic sense it means ‘doing something’ with your data.

Processing these large amounts of data is really not a problem until you put a time constraint into the mix. When you have to process your data within a certain time frame, a growing data set can become a problem. A number of solutions instantly come to mind when you face time-constrained data processing. E.g.:

• Code optimization
• Scaling up your hardware
• Database clustering

The above solutions are a little traditional but they are being used a lot. Though we can also identify other solutions: running code in parallel and distributed computing. In this article we will focus on these two concepts.

Fork Join

Ever since processors are able to we have been trying to optimize our code for this. Especially lately the number of cores a processor has is growing fast. How often haven’t you heard someone say; “the system is slow because modern software doesn’t handle multi-core processing very well”? Hardware vendors try to handle this by simply boosting the speed of a single core when needed (TurboBoost, TurboCore), so software that stresses one core a lot can get a small increase in processor speed. But it would be very nice if developers were able to make use of all the cores available. In Java 7, developers have access to JSR-166: a fork/join framework. What it allows the developer to do is to define a workload and then split the entire workload into smaller pieces which can execute separately. Then the results can be combined into one result.

Distributed Tasks

In distributed computing you will attempt to leverage the processing capabilities of multiple nodes. Granted that the problem allows for such an approach multiple machines could be tasked with a small portion of the problem. Using a technology like GigaSpaces that allows easy implementations of the Map-Reduce pattern a problem could be split into smaller sub-tasks and then sent to multiple machines. The result of each of the machines would then have to be combined to form the full result.
Graphically splitting up the work into smaller sub-tasks could look like:

Then when each of the nodes calculated its result, the results will have to be combined. Which could be displayed as:

With a technology like GigaSpaces (of course there are others that allow this as well) we could achieve the above with something called DistributedTasks.

The problem

For our problem scenario we will have a list, of a decent size, of files. Each holds 20,000 lines of comma separated values. Each line must be processed. Processing in our case means that we consider each individual line and extract the ‘id’ value and count how many occurrences it has in the entire data set. While this problem is not one you will come across in your work (most likely) there are a lot of similar cases imaginable that you will come across.

A solution

It would be very nice if you could leverage the power of a fork-join framework along with the power of multiple nodes. So, our basic setup will be: distribute all the files evenly across our cluster, then on each node process all available files, line by line. All this while maximizing our processor power. In the solution that I created I used GigaSpaces with Java 7. First there is the ‘client’, this is a class that gets a reference to the cluster and fires a DistributedTask into the cluster and then prints out the result:

List results = gigaSpace.getClustered().execute(new CounterTask()).get();
for (Result r : results) {
System.out.println("Result " + r.getId() + " occurred " + r.getOccurrences() + " times");
}

Let’s take a look at the class CounterTask, which is a distributed task. This task will execute on each of the nodes where a subset of all data is present.
The following code snippet shows what the execute() method does of the CounterTask.

Data[] allData = gigaSpace.readMultiple(new Data(), Integer.MAX_VALUE);

for (Data data : allData) {

List lines = readAllLines(data.getContents());

ForkJoinPool pool = new ForkJoinPool();

String[] lineArray = lines.toArray(new String[0]);

Map intermediateResults =

pool.invoke(new Counter(lineArray, 0, lineArray.length));

results.addAll(intermediateResults.values());

}

return results.toArray(new Result[0]);

So, for each of the files (represented by the Data class) all lines inside the file are read into a list and a ForkJoinPool handles splitting the workload over the available processing power. For this the Counter class is used. Let’s take a look at that class. It implements a single method: compute() which return how many times an id occurs. Since we want to maximize our processing power we need to divide the work into smaller parts. However at one point splitting the task would only create more overhead and we should simply do our processing. The THRESHOLD variable is used to determine if we should split the task, or simply process the lines that is given:

if (lines.length >= THRESHOLD) {

int mid = start + (end - start) / 2;

Counter left = new Counter(lines, start, mid);

Counter right = new Counter(lines, mid, end);

left.fork();

Map rightAns = right.compute();

Map leftAns = left.join();

return merge(leftAns, rightAns);

. . .

Notice that this method is called recursively by using the fork(), compute() and join() methods.

If we should simply do the work all lines are iterated and the number of times the ‘id ‘ value occurs is counted:

. . .
} else {

Map results = new HashMap<>(10000);

for (String line : lines) {

Result result = new Result();

String id = line.substring(0, line.indexOf(","));

result.setId(id);

result.setOccurrences(1);

if (results.get(id) == null) {

results.put(id, result);

} else {

Result previousResult = results.get(id);

previousResult.increment(1);

results.put(id, previousResult);

}

}

return results;

Conclusion

The solution application shows how we can distribute the workload across an entire cluster of machines using DistributedTask and on each of the nodes processing power is maximized using the fork-join framework. By no means should you always use this approach, I’ve used it purely to demonstrate how work can be divided and results retrieved. You should always first check if the problem you’re solving can be distributed or split into sub-tasks, or maybe even both like in our example, before you go all out with frameworks like this.

Distributed Fork Join - Tricode

“Qiy is the next big thing and the new privacy standard”. Met deze lovende woorden heeft de jury van Kuppinger Cole op de European Identity Conference in München de European Identity Award 2011 voor privacy toegekend aan Qiy. Initiatiefnemer Marcel van Galen heeft de prijs op woensdag 11 mei in München in ontvangst genomen tijdens de druk bezochte internationale conferentie.Van Galen ziet de Europese Identiteitsprijs als erkenning en ondersteuning van zijn geesteskind. “Qiy is al jaren bezig met de ontwikkeling en nu wordt het breed opgepikt. De European Identity Conference legt enorm veel gewicht in de schaal. Het is een van de grootste en belangrijkste congressen ter wereld op het gebied van IT, risicomanagement, governance en internetprivacy. We zijn dan ook heel trots op de prijs. Het juiste signaal op het juiste moment rondom de internationale doorbraak van Qiy.”

Voor Qiy is deze erkenning ook een erkenning van alle inspanningen van medewerkers, partners en investeerders.

Tricode vervult als technische partner van Qiy al meer dan 3 jaar een belangrijke rol bij het ontwerpen, bouwen en technisch uitrollen van het Qiy platform. Wij combineren hierbij onder andere geavanceerde security-aspecten met semantische database-technologie, cloud-storage en Adobe Flex. In de toekomst willen we ons meer gaan toeleggen op het bouwen van applicaties voor het Qiy platform.

Tricode gelooft in de visie van Qiy en heeft geïnvesteerd in Qiy als obligatiehouder. Sinds april ontvangen daarnaast alle Tricode medewerkers het loonstrookje in hun persoonlijke Qiy account.

Lees voor meer informatie over Qiy en de toekenning van de identity award het artikel op de Qiy website.

Qiy wint European Identity Award 2011 - Tricode

Elke maand organiseert het personeel bij Tricode een maand evenement. Dit keer werd er een pokeravond georganiseerd. Sander Kramer maakte er de volgende video van:

Pokeravond bij Tricode - Tricode

This article was originally featured in the August of 2010 issue of phpArchitect.

Are you using svn:externals, git-submodules or something similar with your Version Control System (VCS) of choice for connecting third-party libraries to your PHP projects?

This article explores ways to handle dependencies in PHP projects, just like projects in other programming languages have done for ages.

Dependencies

Many projects have some kind of external dependency, e.g. libraries, language extensions, system tools or other applications. All these dependencies need to be available for the project to work. In PHP, dependencies like language extensions can be checked to be loaded with calls to the “extension_loaded” or “get_loaded_extensions” functions. The availability of system tools and other application can be checked by calling the command with for example the PHP file_exists function in combination with is_executable. Availability of a required library can be checked by asking for it through the class_exists function when using auto-loading or simply require_once the library and wait for it to fail.

For language extensions, system tools and applications, their availability should be checked. These are dependencies that should not be included in the project package, because they are often platform depended and there is a fair chance that these dependencies are already available on the system running the project. The previous paragraph explained ways of checking them. These checks can be easily executed from an install/release script and let the install fail when something is wrong.

But how about library dependencies? The distributed project package should already contain the required libraries or at least fetch them automatically. Fetching libraries automatically on install sounds good because then the project package for distribution is smaller, saving storage and bandwidth. But it makes your customers, during the installation of the project, depended on the availability of the required libraries from possibly 3rd parties. Think about it. If the current version of your project is still used 5 years from now, can you guarantee that the 3rd parties still provide that specific library version?

On the other hand, when the project is extendable with plugins and modules, fetching the those only when the customer chooses to use them is a fair solution. But the distributed project package should include all the default plugins and modules and all extensions should be fetched from your repository, so you have control over the availability.

svn:externals

How and when are required libraries included in your project?
Many PHP projects, that use Subversion (svn) as their Version Control System (VCS) of choice, use the svn:externals functionality to bind libraries to their project. It’s an easy solution; with every svn checkout or svn update the external libraries are also checked-out and updated into the local working copy. Meaning, it’s possible to directly edit and commit on the external libraries. And svn gives much freedom:

• Add an external pointing to the latest (HEAD) revision
• Add an external pointing to a specific revision
• Add an external from an external repository
• Set the externals property anywhere in the project and including that external somewhere else in the project structure

This means that there is no central location to configure the externals. Everyone working on the project should just know where it is set or search through the svn properties of all the project directories. Dependency management becomes magic “that just works”, or does it?

Ever tried to branch or tag a project that uses svn:externals for dependency management? First branching/tagging all the externals, then updating the svn:externals to those branched/tagged externals and finally create the branch/tag for the project. That’s not workable.

Branching/tagging can be made easier by applying the convention that externals should always point to tags. It’s easier branching/tagging because the externals will then always be pointing to a stable tag version. But svn still offers commit permission on the external that is pointing to a tag. Specifying the revision that the external should point to is the safest way to work with externals, this way the external will always be exact at that revision.

So what’s wrong with using a VCS for dependency management?

• No overview of external configuration, they can be defined and placed anywhere in the project
• Externals must be controlled in the same type of VCS. There’s no way to add a git repository as external in svn, or a simple .tar.bz2-file
• Committing on externals is possible

How do other programming language handle dependencies

The most common lines of an “INSTALL” file of Linux C/C++ projects are

Ever tried that on a big project? Did “make” error-out the first time it ran? And the second time? Telling it missed a specific library and therefore could not continue? Dependencies! The project could not be compiled without having the correct dependencies available.

Java build tools like Apache Maven and Apache Ant with Apache Ivy went a step further. Maven defines the project in a Project Object Model (pom.xml) file, which describes the software project being built. Containing it’s dependencies on other projects/modules and external libraries, a list of the involved developers, links to the version control repository, issue tracker and more. Maven has a central repository which can be used to automatically fetch the project dependencies from, when they exist. Everyone can create their own Maven repository that can be used as a proxy to the central repository. This means the Java project can be build and all needed dependencies are automatically fetched from the central repository or any other repository that is provided in the Maven global settings or project POM configuration. Apache Ant with Apache Ivy works somewhat the same.
This all leads to the fact that with a build tool like Maven, there is a single configuration file per project for defining dependencies. That’s easy and clear for everyone.

The C/C++/Java languages have the advantage to be compiled languages. If a required dependency is missing, the project won’t compile. PHP does not have this advantage. It will run any code until it fails. Therefore PHP projects need some checking for the availability of dependencies.

So, how to apply this on PHP projects?

There is nothing fully equivalent to Maven for PHP except Maven itself with a PHP plug-in. This is what the “Maven for PHP” project does. It’s probably also possible to use Apache Ant with Ivy or other build tools from other programming languages to build PHP projects with. But this has the disadvantage that the build tool is written in a different language than PHP, most probably has no support for PHP specific tools by default and wanting to extend it forces to use the language that the build tool is written in. This makes using a non-native PHP build tool a bit harder.

But there are native PHP tools that provide parts of the features that build tools like Apache Maven provides.
We have Phing, a build tool based on Apache Ant, which has many tasks by default for executing filesystem related commands. Optionally it also contains tasks for many commonly used tools and release methods in the PHP world, like; DbDeploy, FtpDeploy, JsMin, PearPackage, PharPackage, PhpCodeSniffer, PHPUnit and much more. It’s also very easy to extend, just create a PHP class which extends from the Phing Task class and implement a few functions. It can be made as complex as needed, but it’s all in PHP, your language of choice.
For the repository part of a Maven like native PHP tool, we have PEAR for PHP4 and 5 packages and PEAR2 for PHP 5.3.1+ packages. PEAR and PEAR2 are “a framework, packaging and distribution system for reusable PHP Components”. There is a PEAR and PEAR2 framework specific repository, “Channel” in PEAR terms, at http://pear.php.net and http://pear2.php.net respectively. PEAR2 is the next-generation version of PEAR using the new PHP 5+ language features where possible, like namespaces and supports the Phar packaging format. PEAR2 also has a new installer, for installing packages and dependencies, called Pyrus. Pyrus is an easy to use installer which can easily be used standalone without installation from the command-line or be integrated into a project. Just like with Maven, it’s possible to create your own PEAR channel as a repository for projects and dependencies.

All this completes the combined feature list of Phing, PEAR/PEAR2 and Pyrus equal to that of Maven.

One drawback is that Phing does not (yet) has a task for installing dependencies from Pear/Pear2/Pyrus, but tasks doing just that can easily be written. When you do, please contribute it to the Phing project. The same is true for Version Control Systems other than CVS and Subversion, and everything else you want support for.

To conclude

For more information on referenced tools and a direct link to the “Extending Phing” documentation of Phing see the related url’s list. I also want to hint you on the article “Going Industrial” by Stéphen Périn, which was published in the phpArchitect issue of Januari 2010, for more interesting insights and hints on what tools and practices could be used to improve you PHP development life cycle.

Requirements

• PHP: 5.0.2+ (for Phing)
• 5.2+ (for Phar)
• 5.3.1+ (for Pyrus)

Related URLs

• http://www.phing.info
• http://pear.php.net
• http://pear2.php.net
• http://php.net/phar
• http://www.pake-project.com
• http://en.wikipedia.org/wiki/Make_%28software%29
• http://maven.apache.org
• http://ant.apache.org
• http://ant.apache.org/ivy/
• http://phing.info/docs/guide/stable/chapters/ExtendingPhing.html

Version Control != Dependency Management - Tricode