Framework Layer Architecture - 10 Nov 2016

Kisi-Kisi

SOLID Principle
Basic OOP & UML
Introduction Design Pattern
Factory, Prototype, Adapter

Rangkuman Materi Pertemuan 1

Principles of Object Oriented Design :

• Single-responsiblity principle
• Open-closed principle
• Liskov substitution principle
• Interface segregation principle
• Dependency Inversion Principle

Single-responsiblity principle

Sebuah class harus punya 1 tujuan dan hanya 1 tujuan. Jadi 1 Class memiliki tanggung jawab kepada 1 job.

Problem :

public class UserService{
    public void Register(String email, String password){
        if(!email.Contains("@")) 
            throw new ValidationException("Email is not an email!");
        
        var user = new User(email, password);
        _database.Save(user);
        
        _smtpClient.Send(new MailMessage("mysite@nowhere.com", email){Subject="Hello fool!"});
    }
}

Solution :

public class UserService{
    public void Register(String email, String password){
        if(!ValidateEmail(email)) 
            throw new ValidationException("Email is not an email!");
        
        var user = new User(email, password);
        _database.Save(user);
        
        _smtpClient.Send(new MailMessage("mysite@nowhere.com", email){Subject="Hello fool!"});
    }
    
    public bool ValidateEmail(String email){
        return email.Contains("@");    
    }
}

Open-closed principle

Class seharusnya terbuka untuk di inheritance atau di tambahkan extension dari programmer lain tapi tertutup untuk perubahan.

Problem : Checkout function only accept cash, what if there is another payment methods?

void checkOut(Receipt receipt){
    Money total = Money.zero;
    for(item : items){
        total += item.getPrice();
        receipt.addItem(item);
    }
    Payment p = acceptCash(total);
    receipt.addPayment(p);
}

Payment p ;  
if (credit)
    p = acceptCredit(total);
else 
    p = acceptCash(total);  
    
receipt.addPayment(p);

Add if statement to check credit or cash that violate open-close principle

Solution :

public interface PaymentMethod{void acceptPayment(Money total);}
void checkOut(Receipt receipt, PaymentMethod pm){
    Money total = Money.zero;
    for(item : items){
        total += item.getPrice();
        receipt.addItem(item);
    }
    Payment p = pm.acceptPayment(total);
    receipt.addPayment(p);
}

Liskov substitution principle

Child classes should never break the parent class’ type definitions.

Liskov Substitution Principle. Yaitu dimana Liskov Substitution Principle memiliki prinsip dasar yaitu objek pada program yang dibentuk harus replaceable dengan instansi dari subtypes tanpa merubah nilai kebenaran dari program tersebut, dengan kata lain kita harus membuat derived class yang dapat melakukan extend class parentnya TANPA merubah behaviour dari parentnya.

Contohnya :

class Vehicle {
 
    function startEngine() {
        // Default engine start functionality
    }
 
    function accelerate() {
        // Default acceleration functionality
    }
}

class Car extends Vehicle {
 
    function startEngine() {
        $this->engageIgnition();
        parent::startEngine();
    }
 
    private function engageIgnition() {
        // Ignition procedure
    }
 
}
 
class ElectricBus extends Vehicle {
 
    function accelerate() {
        $this->increaseVoltage();
        $this->connectIndividualEngines();
    }
 
    private function increaseVoltage() {
        // Electric logic
    }
 
    private function connectIndividualEngines() {
        // Connection logic
    }
 
}

class Driver {
    function go(Vehicle $v) {
        $v->startEngine();
        $v->accelerate();
    }
}

Interface segregation principle

Client tidak perlu untuk mengimplementasikan interface yang tidak di gunakan atau client seharusnya tidak bergantung kepada method yang tidak di gunakan.

Contohnya :

interface ShapeInterface {
    public function area();
    public function volume();
}  

jika kita membuat interface ShapeInterface semua class yang mengimplementasikannya terpaksa harus menggunakan fungsi volume, sementara square tidak mempunyai volume.

untuk memperbaiki ini kita bisa buat seperti ini

interface ShapeInterface {
    public function area();
}

interface SolidShapeInterface {
    public function volume();
}

class Cuboid implements ShapeInterface, SolidShapeInterface {
    public function area() {
        // calculate the surface area of the cuboid
    }

    public function volume() {
        // calculate the volume of the cuboid
    }
}

Dependency Inversion Principle

Tergantung kepada abstraksi bukan concretion

• High-level modules seharusnya tidak bergantung ke low-level modul. seharusnya tergantung kepada abstraction.
• Abstraction seharusnya tidak tegantung kepada detail. Detail seharusnya tergantung kepada abstraction.

Contohnya :

<?php

class PasswordReminder {
    private $dbConnection;

    public function __construct(MySQLConnection $dbConnection) {
        $this->dbConnection = $dbConnection;
    }
}

?>

MySQLConnection adalah low-level module , sementara PasswordReminder is High-level Karena PasswordReminder Tergantung kepada MySQLConnection maka ini melanggar prinsip dari Dependency Inversion

PasswordReminder class seharusnya tidak perlu tahu apa database yang di gunakan untuk memperbaiki ini kita bisa menambahkan interface karena low-level dengan high-level modul harus tergantung kepada abstraction. kita bisa buat :

<? 

interface DBConnectionInterface {
    public function connect();
}

Dari pada menulis langsung MySQLConnection di constructor dari PasswordReminder, lebih baik kita input interface nya dan tidak peduli apa aplikasi database yang di gunakan ReminderPassword bisa konek ke database tanpa masalah dan tidak melanggar prinsip Open-Close Principle

<? 

class MySQLConnection implements DBConnectionInterface {
    public function connect() {
        return "Database connection";
    }
}

class PasswordReminder {
    private $dbConnection;

    public function __construct(DBConnectionInterface $dbConnection) {
        $this->dbConnection = $dbConnection;
    }
}  

Dari kode di atas kita bisa lihat bahwa low-level dan high-level module sudah bergantung kepada abstraction.

Rangkuman Materi Pertemuan 2

• Java Web Introduction
• Java Object Oriented in Web Programming
• PHP Introduction
• PHP Object Oriented in Web Programming

Website intinya adalah Response dan Request.

Web Pages :

• Statis
• Dinamis

Statis :

Client Browser -> HTTP Request -> Web Server Catch Request -> HTTP Response -> Client Browser Catch Response Web Page Statis tidak melakukan pertukaran data dengan database server. Contoh : Biasanya website berupa company profile.

Dinamis :

Client Browser -> HTTP Request -> Web Server Catch Request -> Web Application/Database Server -> HTTP Response -> Client Browser Catch Response Web yang dinamis akan mengembalikan data tergantung dari parameter yang di request oleh user. Contoh : Seperti Kita Search di google.

Java Web Introduction

Komponen Java Web Application :

• Server harus ada service web server ( Tomcat )
• Biar Bisa Run Java application Harus ada Servlet/JSP Engine or Servlet/JSP Container.

Client Browser -> HTTP Request -> Web Server (Catch Request) -> Servlet/JSP (Processing) -> Database Server (Return Data) -> Servlet/JSP (Catch Data) -> Web Server (Construct Response) -> HTTP Response -> Client Browser (Catch Response)

JSP :

• JSP adalah java code yang di embed dengan HTML
• Pertama kali JSP di Request, JSP Engine translate ke Servlet dan Compile. kemudian servletnya dijalankan oleh servlet engine.

Servlets :

• Servlet adalah java class yang berjalan di web server dan melakukan proses terhadap dynamic web.
• Setelah proses selesai servlet return html code using prinln method ke dalam sebuah object.

// get parameter from request ?nama=Abdillah
String nama = request.getParameter("nama");

IDE ( Integrated Development Environment )

Popular IDE Buat JSP :

• NetBeans
• Eclipse

2 Architecture Web Application :

• Model 1

Jsp menangani 2 request dan response dari application.

• Model-View-Controller (MVC) Pattern
  • Model MVL di kenal sebagai Model 2 Architecture dan lebih baik dari Model 1 Architecture
  • Sebuah Pattern yang standart di gunakan untuk menyelesaikan masalah.
  • Model mendefinisikan design data pada applikasi.
  • View mendefinisikan presentasi layer dari applikasi.
  • Controller memanage alur dari aplikasi.

5 Type of JSP TAGS:

<% %> // Insert Block Of Java Statement (JSP Scriplet)
<%= %> // Display the string value of an expession (JSP Expression)
<%@ %> // Set Condition that apply to the entire JSP (JSP Directive)
<%-- --%> // To Tell JSP Ignore (JSP Comment)
<%! %> // To declare Instance variables and method for JSP (JSP Declaration)

PHP Web Introduction

PHP Kepanjangannya adalah Personal Home Page dan di rilis secara open source. Sekian waktu berjalan PHP di rombak sesuai dengan kebutuhan user. Pada 1997, PHP di rename ke PHP:Hypertext Preprocessor, Seperti yang di ketahui sekarang. Saat ini PHP sudah sampai versi ke 7.x

• PHP IF
• PHP IF ELSE
• PHP WHILE
• PHP CLASS
• PHP INTERFACE
• PHP INHERITANCE
• PHP LOGICAL OPERATOR
• PHP FUNCTION
• PHP POLYMORPHISM

Rangkuman Materi Pertemuan 3

• The MVC Looseb and Refocuses Programming
• Basic Principles of Design Patterns
• Design Patterns as a Big Cheat sheet
• Choosing a design pattern

Why Study Design Patterns

• Reuse Solutions
• Establish Common
• Pattern Give you a higher-level prespective

Design Pattern Organize to 3 Classes:

• Creational

yaitu pattern yang menyangkut dengan pembuatan object.Pattern akan menangani pembuatan suatu object.

• Structural

yaitu pattern yang menyangkut dengan struktur program. dimana dalam Pattern ini akan lebih konsen ke class

• Behavioral

yaitu pattern yang menyangkut tentang kelakuan program. Dimana pada pattern ini akan menjelaskan spesifik tentang komunikasi antar object.

Creational Pattern

• Abstract Factory (Pembuatan Instance Object dari keluarga object (Children Object))
• Builder (Kontruksi Object yang kompleks dengan memisahkan kontruksinya dan penjabaran object tersebut)
• Factory Method (Pembuatan Objet tanpa spesifikasi penjabaran class yang akan di buat)
• Prototype ( Pembuatan object dengan mengkloning dari object yang telah ada)
• Singleton ( Pembatasan pembuatan object dari suatu class)

Rangkuman Materi Pertemuan 4

• Why UML
• Class Diagram
• Object Diagrams
• Interaction Diagrams
• The Role of Diagrams and Notations in OOP
• Tools for UML

Why UML

Unified Modeling Language (UML) Membuat kita mungkin untuk menjelaskan sistem dengan kata dan gambar. Bisa di gunakan untuk memodelkan berbagai sistem : software system, bisnis system, ataupun yang lain

Class Diagram

Class diagram digunakan untuk mengilustrasikan struktur bagian dari sistem. seperti relasi di antara object.

Association : Dapat diartikan sebagai relasi “.. has a..”. Digambarkan sebagai garis lurus antara dua kelas. Namun tidak berarti bahwa kelas satu memiliki/dimiliki kelas yang lain, tetapi kelas lain dapat berelasi juga dengan kelas yang sama.

Directed Association : Relasi seperti asosiasi namun menggambarkan objek atau aliran kejadian berasal dari salah satu kelas, sedang kelas yang lainnya bersifat pasif.

Aggregation : Dapat diartikan sebagai “..owns a ..”(“terdiri atas..”). Terdapat kelas sebagai part class (kelas bagian) yang merupakan bagian dari kelas lain(whole class). Namun jika whole class tidak ada, part class masih dapat berdiri sendiri.

Composition : Bisa disebut juga sebagai strong agregation, dapat diartikan “..is part of..” (“..bagian dari..”). Seperti halnya relasi agregasi, namun apabila whole class hilang, maka mustahil part class untuk ada.

Generalization : Dapat diartikan sebagai relasi “..is a..” Digunakan untuk merepresentasikan pewarisan. Suatu kelas (child class) dapat diturunkan dari kelas lain dan mewarisi semua atribut dan method induknya (parent class) dan dapat menambah method atau atribut baru.

Dependency : Merupakan hubungan ketergantungan antar kelas. Suatu kelas memiliki ketergantungan terhadap kelas lain, tetapi tidak berlaku sebaliknya. Perubahan pada salah satu elemen kelas (pemasok) berdampak pada kelas lain (klien).

Multiplicity : Cardinalitas atau multiplicity adalah simbol yang menunjukkan jumlah instansiai dari satu kelas terkait dengan kelas lainnya.

Visibility

(+) public : visibilitas yang menunjukkan bahwa anggota kelas tersebut dapat diakses oleh kelas lain sekalipun tidak mewarisi kelas yang bersangkutan namun masih memiliki relasi dengan kelas tersebut.

(#) protected : menunjukkan bahwa anggota kelas tersebut hanya dapat dipanggil oleh kelas yang bersangkutan dan kelas anak yang mewarisinya.

(–) private : menunjukkan bahwa anggota kelas tersebut hanya dapat dipanggil oleh kelas yang bersangkutan dan tidak dapat dipanggil oleh kelas lain.

(~) package : menunjukkan atribut tersebut dapat dilihat oleh kelas lain yang masih terdapat dalam paket yang sama.

Object Diagram

Object Diagram will show how objects in your system are interacting with each other at some point in time, and what values those objects contain when the program is in this state.

Perbedaannya dengan Class diagram :

A Class Diagram will show what the Objects in your system consist of (members) and what they are capable of doing (methods).

Interaction Diagram

Dalam UML ada 2 diagram yang menggambarkan interaksi antar obyek :

• Sequence Diagram
• Collaboration diagram

Persamaan sequence diagram dan collaboration diagram :

Menampilkan objek yang berpartisipasi dalam aliran melalui use case dan pesan yang dikirim antar objek.

Sequence diagram:

• Diperintahkan oleh waktu.
• Berguna jika seseorang ingin mereview flow of logic melalui skenario.
• Menyediakan cara untuk melihat skenario dalam time-based order : apa yang terjadi pertama, apa yang terjadi berikutnya, dll. Digunakan untuk menentukan message ordering .

Collaboration diagram:

• Diatur sekitar obyek itu sendiri.
• Berguna jika Anda ingin menilai dampak perubahan. Sangat mudah untuk melihat pada collaboration diagram, objek yang berkomunikasi dengan objek yang lain. Jika Anda ingin mengubah objek, Anda dapat dengan mudah melihat objek-objek lain yang mungkin akan terpengaruh.
• Memberikan gambaran besar untuk skenario, karena mereka diorganisir sekitar bagaimana objek me-link ke satu dan yang lainnya. Digunakan untuk menentukan class relationships.

Tools For UML

• StarUML

Rangkuman Materi Pertemuan 5

• Factory Method Pattern
• When to use Factory Method
• Factory Method Examples
• Acommodating Class Change

Factory Method Pattern

Factory Pattern adalah pattern yang digunakan untuk memisahkan (decouple) proses pembuatan/instansiasi sebuah objek (produk) dari objek lain (klien) yang menggunakannya. Tujuannya supaya perubahan pada product class nggak menyebabkan kita harus mengubah kode pada client. Paling nggak akibat dari perubahan itu bisa diminimalisir. Dan juga supaya si factory bisa digunakan oleh banyak class.

When to use Factory Method

• Ketika SubClass dari Class Parent Bisa Beragam.
• a class can’t anticipate the class of objects it must create.
• a class wants its subclasses to specify the objects it creates.
• If a class has a finite and known number of objects it must create, the class can be built so that the finite number of objects can be created in a predictable manner.
• A programming product to deal with that kind of variation needs to have a good deal of flexibility built into it. This is the kind of project where you would want to consider using a Factory Method design

Contoh : fungsi untuk open image

    
    public Image CreateImage(String type){
        if(type.isEqual("png"))
            return new PNGImage();
        if(type.isEqual("jpg"))
            return new JPGImage();
        if(type.isEqual("gif"))
            return new GIFImage();
    }
    
    public void NewImage(String type){
        Image im = CreateImage(type);
        Images.add(im);
        im.open();
    }
    
    //NewImage("jpg");    

When to use Abstract Factory Method

• Softwarenya butuh untuk menjadi independen dari yang sudah ada
• Ingin mengisolasi class concrete yang dihasilkan.
• Nama-nama class implementation yang sebenarnya tidak perlu diketahui pada sisi klien

Perbedaan Factory Method Dengan Abstract Factory Method

• Factory Method is used to create one product only but Abstract Factory is about creating families of related or dependent products.
• Factory Method pattern exposes a method to the client for creating the object whereas in case of Abstract Factory they expose a family of related objects which may consist of these Factory methods.
• Factory Method pattern hides the construction of single object where as Abstract factory method hides the construction of a family of related objects. Abstract factories are usually implemented using (a set of) factory methods.
• AbstractFactory pattern uses composition to delegate responsibility of creating object to another class while Factory design pattern uses inheritance and relies on derived class or sub class to create object.
• The idea behind the Factory Method pattern is that it allows for the case where a client doesn’t know what concrete classes it will be required to create at runtime, but just wants to get a class that will do the job while AbstractFactory pattern is best utilised when your system has to create multiple families of products or you want to provide a library of products without exposing the implementation details.!

Rangkuman Materi Pertemuan 6

• Prototype Design Patterns Introduction
• When to use the prototype pattern
• The Clone Function
• Prototype Pattern Example

Prototype pattern

Pola Prototipe menentukan jenis objek untuk membuat menggunakan contoh prototipikal. Prototipe produk baru sering dibangun sebelum produksi penuh

When to use prototype pattern

Prototype pattern bisa di gunakan di applikasi apapun di mana kita butuh untuk membuat beberapa instance dari prototypical object

When to use builder pattern

Pola ini digunakan ketika algoritma pembuatan obyek harus dipisahkan dari sistem, dan beberapa representasi dari algoritma penciptaan diperlukan.

Rangkuman Materi Pertemuan 7

• Adapter Pattern Introduction
• When to use the adapter pattern
• The Adapter Pattern Using Inheritance
• The Adapter Pattern Using Composition

Adapter Pattern Introduction

• Mengkonversi antarmuka dari kelas ke antarmuka lain klien harapkan. Adapter memungkinkan kelas bekerja sama yang tidak bisa dinyatakan karena interface yang tidak kompatibel.
• Bungkus kelas yang ada dengan antarmuka baru.
• Impedansi sesuai komponen lama ke sistem baru.

When to use adapter pattern

Ketika suatu class tidak kompatible dengan permintaan client maka di butuhkan adapter untuk menyesuaikan dengan interface yang diharapkan oleh client.

Facade Pattern Introduction

• Menyediakan antarmuka yang seragam untuk satu set antarmuka di subsistem. Fasad mendefinisikan antarmuka tingkat tinggi yang membuat subsistem yang lebih mudah digunakan.
• Wrap a complicated subsystem with a simpler interface.

When to use facade pattern

Facade mendefinisikan, antarmuka tingkat yang lebih tinggi bersatu untuk subsistem yang membuatnya lebih mudah untuk digunakan.

Operating Sistem - 12 Nov 2016

Kisi-Kisi
Operating Sistem
- PG 10 Soal(20 %)
> Session 1-7
- Essay ( 80% )
1. Process(Fork/Interrupt)
2. Thread (Advantages)
3. Schedule(3)(FCFS/SJFP/RR/Q)
4. Deadlock
5. Concurrency(Problem)

HOT :
1. Computer Architecture (Page 39)
2. Basic Instruction Cycle(Page 41)
3. Memory Hierarcy(Page 55)
4. Process Characteristic (Page 138)
5. Five State Process Model(page 146)
6. Reason For Process Switch (Slide Notes)
7. Process amd Threads(Page 183 - 189)
8. Scheduling Algorithm ( Page 432 - 446)
    a. First Come First Server
    b. Pre-empetive Shortest Job(SFJ)
    c. Round-Robin With Quantum
    Yang di tanya adalah ?Turn Around-Time ?Average Waiting Time
    
9.Concurency (Page 231)
10.Deadlock (Page 298-301)


Baca Tententang Process/Intercept
Baca Thread
Perbandingan Keuntungan Process & Thread
Bagaimana Flow Pada Process
Bagaimana Process Flow dalam Thread
Scheduling (FirstComeFirstServe,Shortest Job First,Round-Robin) Gambar Terus itung rata2 waiting time dan rata2 turn around time