obrazek pochodzi z serwisu http://blog.webspecies.co.uk

Chmur dedykowanych PHP jest wiele nie ma. Najpopularniejszą z nich jest PHPFog działający na infrastrukturze Amazonu. Wszystkie pozostałe rozwiązania są natury ogólnej, pozwalającej wprawdzie uruchomić PHP, ale wymagające od programisty pewnej wiedzy na ten temat. Firma Web Species chce to zmienić i pracuje nad kolejną chmurą dedykowaną PHP, lecz w przeciwieństwie do pozostałych rozwiązań, chmura będzie korzystała z infrastruktury Windows Azure. Dlaczego akurat ta chmura? Ponieważ wszystkie inne zbudowane są w oparciu o chmurę Amazonu:

There is nothing specific about Azure that we wanted to leverage, but because so many existing PaaS providers are built on Amazon cloud it just made sense to try something else.

Wyjaśnienie należy do kategorii tych lżejszych, ale autorzy na pewno wiedzą co robią.

Niestety w chwili obecnej nie ma zbyt wiele informacji na temat Azure+ ponad to, że będzie działał na Windows Azure i zdejmował z barków programistów obowiązek instalowania i konfigurowania środowiska. Lista dostępnych funkcjonalności zamyka się w obrębie kilku głównych zagadnień. Są to:

• deploy – sposób wdrażania aplikacji do chmury
• zarządzanie aplikacją – błyskawiczna zmiana ustawień aplikacji, wersji PHP oraz aktualizacja kodu
• dwa środowiska – produkcyjne i deweloperskie
• logowanie – wszystkie zmiany w aplikacji są logowane, dzięki czemu jest możliwość dokładnego śledzenia wprowadzanych zmian

Strona projektu nie dostarcza zbyt wiele dodatkowych informacji, ale i tak warto na nią zajrzeć – http://cloud.webspecies.co.uk/. W chwili obecnej dostęp do chmury jest ograniczony do niewielkiej ilości testerów.

Tak przy okazji refleksji i rozmyślań filozoficznych, postanowiłem zademonstrować, jak w języku pokroju Javy zaimplementować rozwiązanie problemu obliczania ceny wszystkich produktów w koszyku.

Proceduralnie:

public class Produkt {
    private Integer cena = 0;
    private Integer ilosc = 0;
    private String nazwa = "";

   public Produkty(Integer cena, Integer ilosc, String nazwa);

    /** tu gettery i settery dla wszystkich parametrow parametrow **/

}

public class Koszyk {

    private List<Produkt> produkty;

    public List<Produkty> getProdukty();
    public void setProdukty(List<Produkty> produkty);

}

public class KoszykUtil {

    public static Integer podliczKoszyk(Koszyk koszyk){
        List<Produkty> produkty = koszyk.getProdukty();
        Integer suma = 0;        

        for(Produkt produkt: produkty){
            suma+= produkt.getCena() * produkt.getIlosc();
        }
        return suma;
    }
}

Produkt p1 = new Produkt(12, 1, "baton z ropą");
Produkt p2 = new Produkt(13, 1, "baton z benzyną");
List<Produkty> produkty = new ArrayList<Produkty>();
produkty.add(p1);
produkty.add(p2);

Koszyk k = new Koszyk();
k.setProdukty(produkty);

Integer suma = KoszykUtil.podliczKoszyk(k);
System.out.println(suma);

Obiektowo:

public class Produkt {

    private final String nazwa;
    private final Integer cena;
    private Integer ilosc;

    public Produkt(String nazwa, Integer cena, Integer ilosc);
    public Integer suma(){
        return cena*ilosc;
   }

}

public class Koszyk {

    private List<Produkt> produkty;
    private Integer wartosc = 0;    

    public dodajProdukt(Produkt produkt){
        produkty.add(produkt);
        wartosc += produkt.suma();
    }

    public Integer wartosc(){
        return wartosc();
    }
}

Koszyk k1 = new Koszyk();
Produkt p1 = new Produkt("baton z benzyna" , 10, 1);
Produkt p2 = new Produkt("baton z ropą", 10, 1);
k1.dodajProdukt(p1);
k1.dodajProdukt(p2);

Integer suma = k1.wartosc();
System.out.println(suma);

Funkcyjne:

public interface Sumator<D> {

     public Integer sumuj(Integer suma, D element);
}

public class Util {

    public static <T> Integer sumuj(Sumator s, List<T> dane) {
        Integer suma = 0;
        for (T element : dane) {
            suma = s.sumuj(suma, element);
        }
        return suma;

    }
}

public final class Produkt {
    public final Integer cena;
    public final String nazwa;

    public Produkt(String nazwa, Integer cena){
        this.nazwa = nazwa;
        this.cena = cena;
    }
}

Produkt p1 = new Produkt("baton z ropą", 10);
Produkt p2 = new Produkt("baton z benzyna", 10);

List<Produkt> produkty = new ArrayList<Produkt>();
produkty.add(p1);
produkty.add(p2);

produkty = java.util.Collections.unmodifiableList(produkty);
Integer suma = Util.sumuj(new Sumator<Produkt>() {

            @Override
            public Integer sumuj(Integer suma, Produkt element) {
                return suma + element.cena;
            }
        }, produkty);

System.out.println(suma);

Czego można dowiedzieć się z tych prostych przykładów ? Otóż można zauważyć w każdym z nich cechy charakterystyczne danego stylu programowania i tego na co kładzie nacisk.

1. Proceduralny – stawia na swobodny przepływ danych.
2. Obiektowy – abstrakcja, enkapsulacja, odwzorowanie modelu domeny
3. Funkcyjny – niezmienność (immutability), generyczność i funkcja jako pełnoprawny element języka (tutaj emulowana przez anonimową klasę)

Mam nadzieje, że powyższe przykłady były pouczające.Jestem bardzo ciekawy, które z powyższych rozwiązań przypadło Wam do gustu i dlaczego, oraz jaki styl preferujecie.