itech9

From http://techinterviewcoach.com/blog/?p=30#more-30

• Hash tables are backed by arrays.
• A hash function is used to map the keys to an index within the backing array.
• Put, Get, Delete operations all run in constant ( O(1) ) time.
• Hash function determines performance.
• Even with the best hash function, collisions can occur.
• Main advantage of HTs over other data structures is speed.
• Growing HTs need to be rehashed but the cost is amortized by constant cost of ‘put’.
• Should not use HTs for small data sets, but everybody does.
• Rehashing should occur when the load factor (occupied array slots / array size) reaches over .75.

• — SOA – Service Oriented Architecture
  — 3 major roles: Provider, Registry (Broker) and Requester.
  — SOA is based on web services.
• — SOAP – Simple Object Access Protocol
  — 2 major methods: Message-based Document Exchange AND RPC
  (Remote Procedure Calls).
  — All structures based on XML.
  — A SOAP message contains an Envelope and a Header.
  — A SOAP message may contain (MIME) attachments.
  — Main transport protocol is HTTP(S).
  — Providers (Receivers) are usually based on Servlets.
• — SOAP-RPC
  — Method signatures contain a single SOAP structure.
  — SOAP service methods must match info in deployment descriptor.
  — Errors and Faults: VersionMismatch, MustUnderstand, DTDNotSupported, etc..
• — WSDL – Web Services Description Language
  — WSDL is an XML grammar for describing a web service
  as a collection of access end-points capable of exchanging
  messages in a procedure- or document-oriented fashion (p. 72)
  — The reasonable flow is to create service methods and
  than generate WSDL from code using tools.
  — Best practices: web service is (functionally) coarse-grained
  and messages are more business-oriented than programmatic.
• — UDDI – Universal Description, Discovery and Integration
  — Similar to an Internet search engine for businesses.
  — UBR – UDDI Business Registry (the Public Cloud).
  — Designed for B2B mostly.
  — 2 APIs: inquiry and publishing API.
  — JAXR = Java API for XML Registries.
  — Some details: Categorization (NAICS, ISO, etc..),
  Identifier (DUNS, Thomas Reg, etc),
  tModel (web service metadata)
• — JAX-RPC and JAXM
  — JAXM = Java API for XML Messaging.
  — JAX-RPC = Java API for XML-based RPC.
  — JAXM may be used as a frontend to SOAP-based messaging
  frameworks through the use of “profiles”.
  — JAX-RPC covers code generation for client and server parts,
  dynamic SOAP, creating services within J2EE and J2SE environments,
  bindings, serialization, mapping of datatypes between WSDL and Java,
  etc..
• — The Java Web Service (JWS) Standard
  — Proposed by BEA, using templates to create simple web services.
  — Example (HelloWorld.jws <- note the .jws extension)
  Note the annotations @operation, @conversation ..

  import com.bea.jws.*
  
  public class HelloWorld extends Service {
    /**
    * @operation
    * @conversation stateless
    */
    public String getHelloWorld() {
      return "Hello, World!";
    }
  }
  

  Other values for @conversation are ‘start’, ‘continue’ or
  ‘finish’. The ‘start’ directive, for example, starts a session.

• — Security notes
  — Use of SSL (HTTPS), encryption, signing and secure hashing.
  — Security Assertion Markup Language (SAML) – used with Single Sign-On (SSO).
• — Resources
  http://aws.amazon.com/
  http://seekda.com/
  http://www.programmableweb.com/
  http://www.webservices.org/
  http://xmethods.com/

Colophon – European (Alpine) Ibex – a wild goat.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class TestPattern {
    public static void main(String[] args) {
	String pin = "1234567";
	String pinPattern = "[0-9]+";
	String result = null;

	Pattern pattern = Pattern.compile(pinPattern);
	Matcher matcher = pattern.matcher(pin);

	result = "";
	while(matcher.find()) {
	    result += matcher.group();
	}
	if (result.equals(pin)) {
	    result = "PIN accepted";
	}
	else {
	    result = "PIN invalid";
	}
	System.out.println(result);
    }
}

SOAP – Simple Object Access Protocol
WSDL – Web Services Description Language
UDDI – Universal Discovery, Description and Integration

Major characteristics:
— XML-Based
— Loosely coupled – interfaces may change without loss of service.
— Coarse-grained – provide high-level business functions.
— Both synchronous and Asynchronous
— Supports RPC (Remote Procedure Calls)
— Supports document exchange

• — Inheritance from anything (including abstract)
  should be a function of the business model.
• — If a class does not _really_ inherit from
  an abstract, one should not use it.
• — Use interface to avoid the problem of multiple
  inheritance.
• — Use interface to improve modularity.. if one
  uses an abstract class and the class changes,
  it may break subclasses.
  (not method signatures but logic/code.. changing
  method signatures is a problem for both abstract
  and interface)
• — Use interfaces when some part of the design
  will change frequently.
• — Interface for plug-in architectures – like
  the strategy pattern.
• — Use abstract class to provide basic services
  for derived classes (event, message handling)
• — In favor of abstract class:
  • — interfaces may be more difficult to read in
    code logic.
  • — interfaces are somewhat slower due to
    indirections.