I am a core Java/Scala backend developer and I would like to experiment new programming languages and frameworks where I see a fit to overcome issues that make the life easier compared to solutions that I am used to apply. Plus it gives you better understanding of alternative ways to get things done.

One of the issues I dealt with recently was one of Spring/Java + Tomcat project taking a few minutes to startup that really needed to be fastened up. I took the chance to implement it in Node to see how fast it would be. (Happened to be a few secs!) It came with its own perils though where I had to implement some complementary Java services again. At the end, that was a nice experiment that worth trying.

Let’s dive into the details. Below you fill find sections each explains how I implemented the solution.

NestJS

If you want to develop a microservice in Node, the obvious path is to use plain vanilla Javascript with the great ExpressJS. I started with that. There are bunch of boilerplate templates to start a microservice project. And adding transpilers such as Babel you can use the new EcmaScript features in your project. After some experimeting, I came across with a nice framework that handles bunch of things, the most important: “Dependency Injection”. That would be a good fit for people like me who worked with frameworks like Spring, Play for some long time. So I decided to make a switch to Nest.

Here is an excerpt from NestJS introduction:

Nest is a framework for building efficient, scalable Node.js server-side applications. It uses progressive JavaScript, is built with TypeScript (preserves compatibility with pure JavaScript) and combines elements of OOP (Object Oriented Programming), FP (Functional Programming), and FRP (Functional Reactive Programming).

That is a good premise. The more I worked with it, the more I liked it. Unlike express, nest is an opionated one. It is written in TypeScript which brings type checking. It has dependency injection and gives you the option to clearly define components of your service.

A typical Nest application has modules which basically provides and exposes classes, interfaces, services, controllers, etc. to itself or other modules. There’s a nice nest-cli which eliminates boilerplate to create a project and components as you go.

I started to develop complementary Java services as Nest services. Those are mostly clients of other microservices such as accessing external configuration, geo ip location, session, etc. To be able to use other microservices in a non-blocking, reactive mode, nest comes with an HttpService which depends on Axios/RxJs.

Below is an example of how to implement a service (e.g. session service client):

import { Injectable, HttpService } from '@nestjs/common';
import { PropertiesService } from '../properties/properties.service';
import { LoggerService } from '../logger/logger.service';
import { Observable } from 'rxjs';
import { AxiosResponse } from 'axios';

type Nullable<T> = T | null;

export interface Session {
  readonly sessionId: string;
  readonly playerId: number;
  readonly inactivityTimeout: number;
}

@Injectable()
export class SessionService {
  constructor(private readonly http: HttpService, private readonly properties: PropertiesService, private readonly logger: LoggerService) {}

  async get(sessionId: string): Promise<Nullable<Session>> {
    this.logger.debug(`Will get session by: ${sessionId}`);
    if (!sessionId) {
      Promise.reject(new Error('Invalid session id'));
    }

    const baseUri: string = await this.properties.get('SYSTEM/SESSION_SERVICE/ENDPOINT', () => '');
    if (!baseUri) {
      Promise.reject(new Error('No baseUri for session service'));
    }

    const response: Observable<AxiosResponse<Session>> = this.http.get(`${baseUri}/sessions/${sessionId}`);
    return response.toPromise()
      .then(axiosResponse => {
        if (axiosResponse.status === 200 && axiosResponse.data) {
          const session: Session = axiosResponse.data;
          this.logger.debug(`Session => ${JSON.stringify(session)}`);
          return session;
        }
        this.logger.debug(`Response status is not ok. Session => null`);
        return null;
      })
      .catch(reason => {
        this.logger.error(`Error in getting session. Session => null. (${reason})`);
        return null;
      });
  }
}

Configuration

As for the configuration of the service, the npm package dotenv was what I chose. First it would allow you to have different sets of configurations for different environments (i.e. development, test, production) that can be controlled using env variable NODE_ENV. Upon that using another npm package joi you can validate configuration once you load it. Finally to go with Nest way, I created the service: ConfigurationService which I can inject it wherever needed.

Here is a configuration file for development:

NODE_ENV=development
PORT=3000
ETCD_HOST=localhost
LOG_PATH=./logs
LOG_FILE=application.log
LOGSTASH_ENABLED=false
GEOIP_HOST="geoip:8080"

and the code snippet from configuration service:

export interface EnvConfig {
  [key: string]: string;
}

@Injectable()
export class ConfigService {
  private readonly envConfig: EnvConfig;

  constructor(filePath: string) {
    const config = dotenv.parse(fs.readFileSync(filePath));
    this.envConfig = this.validateInput(config);
  }

  // ...
}

and here is how you can validate your config file:

  private validateInput(envConfig: EnvConfig): EnvConfig {
    const envVarsSchema: Joi.ObjectSchema = Joi.object({
      NODE_ENV: Joi.string()
        .valid(['development', 'production', 'test', 'provision'])
        .default('development'),
      PORT: Joi.number().default(3000),
      ETCD_HOST: Joi.string().required(),
      ETCD_PORT: Joi.number().default(4001),
      LOG_PATH: Joi.string().required(),
      LOG_FILE: Joi.string().required(),
      LOGSTASH_ENABLED: Joi.boolean().default(false),
      LOGSTASH_HOST: Joi.string(),
      LOGSTASH_PORT: Joi.number(),
      GEOIP_HOST: Joi.string(),
    });

    const { error, value: validatedEnvConfig } = Joi.validate(
      envConfig,
      envVarsSchema,
    );
    if (error) {
      throw new Error(`Config validation error: ${error.message}`);
    }
    return validatedEnvConfig;
  }

Logging

For logging, the number one npm package is winston, I started to use it as well. I had a couple of requirements for logging:

• I should be able to log incoming requests and outgoing responses with the payload,
• I should be able to send logs to our ELK,
• I should be able inject logging service into others where I need to log something.

I was able to handle all with winston. But on sending logs to ELK, using an npm package winston-logstash which provides a new Transporter that you can configure to which logstash instance logs should be shipped to.

Then, I came across log4js. As a loyal user of log4j, I jumped in to that and learning that with the addition of another package logjs-logstash-tcp I implemented my LoggerService as:

@Injectable()
export class LoggerService implements NestLoggerService {
  private readonly log4jsLogger: Logger;

  constructor(private readonly config: ConfigService) {
    this.log4jsLogger = getLogger();

    const log4jsConfig: Configuration = {
      appenders: {
        access: {
          type: 'dateFile',
          filename: `${this.config.getLogPath()}/access.log`,
          pattern: '-yyyy-MM-dd',
          category: 'http',
        },
        app: {
          type: 'file',
          filename: `${this.config.getLogPath()}/${this.config.getLogFile()}`,
          maxLogSize: 5242880,
          numBackups: 5,
        },
        errorFile: {
          type: 'file',
          filename: `${this.config.getLogPath()}/error.log`,
        },
        errors: {
          type: 'logLevelFilter',
          level: 'ERROR',
          appender: 'errorFile',
        },
      },
      categories: {
        default: { appenders: ['app', 'errors'], level: 'INFO'},
        http: {appenders: ['access'], level: 'INFO'},
      },
    };

    if (this.config.isLogstashEnabled()) {
      log4jsConfig.appenders.logstash = {
        type: 'log4js-logstash-tcp',
        category: 'default',
        host: this.config.getLogstashHost(),
        port: this.config.getLogstashPort(),
        fields: {
          source: 'co-game-loader',
          environment: os.hostname(),
          group: process.env.NODE_ENV,
        },
      };
      log4jsConfig.categories.default.appenders.push('logstash');
    }

    if (process.env.NODE_ENV !== 'production') {
      log4jsConfig.appenders.console = {
        type: 'console',
      };

      log4jsConfig.categories.default.appenders.push('console');
      log4jsConfig.categories.default.level = 'DEBUG';
    }

    configure(log4jsConfig);
  }

Here I need to mention a two things:

One, you can extend NestLoggerService to be able to write the logging service. By doing that Nest was able to be use it for its logging needs. You can add your logger on bootstrapping the Nest application like:

async function bootstrap() {
  const app = await NestFactory.create(AppModule, { logger: false });
  app.useLogger(app.get(LoggerService));
  // ...
}
bootstrap();

Then, you can configure log4js in a .js file over which a typical log4j user prefers to do in a config file. Doing so gives you the flexibility to customize logging depending on envrionment variables or your service configuration. See for instance how to send logs to logstash as well conditionally:

if (this.config.isLogstashEnabled()) {
  log4jsConfig.appenders.logstash = {
    type: 'log4js-logstash-tcp',
    category: 'default',
    host: this.config.getLogstashHost(),
    port: this.config.getLogstashPort(),
    fields: {
      source: 'co-game-loader',
      environment: os.hostname(),
      group: process.env.NODE_ENV,
    },
  };
  log4jsConfig.categories.default.appenders.push('logstash');
}

or how to enable console logging for environments other than production:

if (process.env.NODE_ENV !== 'production') {
  log4jsConfig.appenders.console = {
    type: 'console',
  };

  log4jsConfig.categories.default.appenders.push('console');
  log4jsConfig.categories.default.level = 'DEBUG';
}

Testing

As Nest comes with a very good testing framework Jest, I did not search for more and just tried to stick with it. When you create a Nest component via nest-cli, there you have the initial code to write the tests for that component. With a little read and try-and-fail, I was able to write tests for all the services, classes, I created. It helped a lot especially finding errors I made during implementation. I will not go into the details of how to write tests using Jest. I just want to share an example here to give you the feel of a simple test:

describe('SessionService', () => {
  let service: SessionService;
  let logger: LoggerService;
  let properties: PropertiesService;
  let http: HttpService;

  beforeAll(async () => {
    const module: TestingModule = await Test.createTestingModule({
      imports: [HttpModule, PropertiesModule, LoggerModule],
      providers: [SessionService],
    }).compile();
    http = module.get<HttpService>(HttpService);
    properties = module.get<PropertiesService>(PropertiesService);
    logger = module.get<LoggerService>(LoggerService);
    service = new SessionService(http, properties, logger);

    jest.spyOn(logger, 'debug').mockImplementation((message: any, context?: string) => console.log(message));
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  it('should return EMPTY when session service request responds with status code NOT OK', async (done) => {
    const mockGet = jest.spyOn(properties, 'get').mockImplementation((key: string, defaultSupplier: any) => Promise.resolve('http://session-service-host'));
    jest.spyOn(http, 'get').mockImplementation(() => of({status: 500}));

    await expect(service.get('session-id')).resolves.toEqual(null);

    expect(mockGet).toBeCalledWith('SYSTEM/SESSION_SERVICE/ENDPOINT', expect.any(Function));

    done();
  });

  it('should return SESSION when session service request responds with status OK and session', async (done) => {
    const mockGet = jest.spyOn(properties, 'get').mockImplementation((key: string, defaultSupplier: any) => Promise.resolve('http://session-service-host'));
    const expectedSession = {sessionId: 'sessionId', playerId: 1, inactivityTimeout: 10}
    jest.spyOn(http, 'get').mockImplementation(() => of({status: 200, data: expectedSession}));

    await expect(service.get('session-id')).resolves.toEqual(expectedSession);

    expect(mockGet).toBeCalledWith('SYSTEM/SESSION_SERVICE/ENDPOINT', expect.any(Function));

    done();
  });
});

Jest requires you write tests in BDD style. Before all, I had to create a test module and bring dependant modules into my test scope. Then I created mocks for defining test behaviours of dependant services.

Debian Packaging

As I see it, typical deployment of a Node service is either docker or checking out the source from a repo and running it node (e.g. node server.js). In my case, those were not the options and since the original source code (in TypeScript) needs to be compiled into plain vanilla Javascript that Node can understand and I needed to create a deb(ian) package. Here another npm package node-deb helped. With node-deb you can create packages that can be installed as a system service on a target machine.

To be able use node-deb and control how the package will be created. First I needed to add instructions to package.json:

"devDependencies": {
    "node-deb": "^0.10.7"
  },

 "node_deb": {
    "init": "none",
    "dependencies": "base-passwd, adduser (>= 3.11), nodejs",
    "entrypoints": {
      "cli": "dist/main.js"
    }
  }

where I basically defined the entry point and dependent debian packages and added npm run scripts like:

  {
    "predeb:test": "rimraf dist && tsc",
    "deb:test": "./node_modules/node-deb/node-deb --no-default-package-dependencies --template-default-variables deb/env-test -- test.env dist/",
    "predeb:prod": "rimraf dist && tsc",
    "deb:prod": "./node_modules/node-deb/node-deb --no-default-package-dependencies --template-default-variables deb/env-production -- production.env dist/"
  },

to build the deb package for test and production targets. And to introduce environment variables (NODE_ENV in my case) to the service, I needed to tell node-deb the template. Here is the production.env template:

# This file was autogenerated by node-deb 
#
# Configuration for the  daemon
#
NODE_ENV="production"

With this setup, I was able to build the deb package even in Jenkins and to push it to an internal repo, where target server machines can pull and (re)deploy the service automatically with the help of puppet.

Final words

I hope that I will help to the adventurers of Node by at least giving useful insights how to write a microservices in Node.

SpringBoot and Akka are two powerful frameworks both have their own strengths and can be used alone to develop microservices. You can argue both has some pros and cons. Although it mostly depends on the taste of the developer, I love SpringBoot a lot when it comes to building microservices quickly with the help of huge support for integrations with almost any service you may need. Akka on the otherhand has a very solid actor model for developing concurrent and distributed applications but, imho compared to spring, it lacks easy dependency injection; designing REST endpoints with AkkaHttp is not straight forward and integrations with services are limited.

Let’s jump into solution how I made use of SpringBoot and Akka together. To give some background, let me explain my case a little: In a typical online casino setup, a casino operator hosts games of a provider on its portal. There is a two way integration between online casino and game provider services to be able to launch game and to be able to process money transactions on player’s account for bets and winnings. A wallet server is a service on casino side that provides a set of REST endpoints which handles money transaction on a player’s wallet during game play.

SpringBoot fits nicely on setting up endpoints, injecting dependencies, processing database transactions, etc. and Akka is a great fit to model each players interaction with his wallet as an actor per game play and to supervise all players’ game play sessions.

Below you can find specific implementation sections with example code snippets.

SpringBoot JAX-RS

JAX-RS is a well-defined standart for developing REST endpoints and you can use JAX-RS with SpringBoot. All you need to do is to bring right dependencies into the scope.

dependencies {

    testCompile 'junit:junit'

    // Spring
    compile 'org.springframework.boot:spring-boot-starter-jersey'
    testCompile 'org.springframework.boot:spring-boot-starter-test'
    
}

I chose JAX-RS over Spring MVC, I believe, JAX-RS has better model than Spring MVC. But using it, brings a small overhead that is you need to configure it manually which is fairly easy as a Spring configuration class:

@Configuration
public class JerseyConfig  extends ResourceConfig {

    public JerseyConfig() {
        packages("com.yboyacigil.experiments.springboot.akka.walletserver.endpoints");

        register(LoggingFeature.class);
        property(LoggingFeature.LOGGING_FEATURE_LOGGER_LEVEL_SERVER, "INFO");
    }
}

Akka

As mentioned above, I created one actor to handle all requests of a player during game play. Since actors have one mailbox for messages and messages are processed in order, that makes it more suitable in processing bets & winnings in the order it has received. Simply named it GamePlayActor as follows:

@Component
@Scope("prototype")
public class GamePlayActor extends AbstractLoggingActor {

    private AccountingService accountingService;

    public GamePlayActor(AccountingService accountingService) {
        this.accountingService = accountingService;
    }

    @Override
    public Receive createReceive() {
        return receiveBuilder()
            .match(GetCurrency.class, this::receiveGetCurrency)
            .match(GetBalance.class, this::receiveGetBalance)
            .matchAny(o -> log().info("Received unknown message: {}", o))
            .build();
    }

  // rest is omitted
}

As you notice, the actor is defined as a Spring component with prototype scope that is a necessity for actor system andSpring can inject all dependencies that it needs.

We need one more thing which is an extension for actor system that can produce actor instances with their dependencies.

import akka.actor.Extension;
import akka.actor.Props;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class SpringExtension implements Extension {

    private ApplicationContext applicationContext;

    public void initialize(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    public Props props(String actorBeanName) {
        return Props.create(SpringActorProducer.class, applicationContext, actorBeanName);
    }
}

where SpringActorProducer is a factory class for creating actor instances as Spring beans:

import akka.actor.Actor;
import akka.actor.IndirectActorProducer;
import org.springframework.context.ApplicationContext;

public class SpringActorProducer implements IndirectActorProducer {

    private final ApplicationContext applicationContext;
    private final String actorBeanName;

    public SpringActorProducer(ApplicationContext applicationContext,
        String actorBeanName) {
        this.applicationContext = applicationContext;
        this.actorBeanName = actorBeanName;
    }

    @Override
    public Actor produce() {
        return (Actor) applicationContext.getBean(actorBeanName);
    }

    @SuppressWarnings("unchecked")
    @Override
    public Class<? extends Actor> actorClass() {
        return (Class<? extends Actor>) applicationContext.getType(actorBeanName);
    }
}

Reactivity

Akka actor are by design reactive. To complete the picture, you can use JAX-RS AsyncResponse in your endpoint:

@GET
@Path("/players/{pid}/account/balance")
@Produces(MediaType.APPLICATION_JSON)
public void getBalance(@Suspended final AsyncResponse asyncResponse, @PathParam("pid") Long pid) {

  GetBalance getBalance = GetBalance.builder()
    .pid(pid)
    .gameCode("not-important-atm")
    .build();

  askForResult(asyncResponse, getBalance);
}

@SuppressWarnings("unchecked")
private void askForResult(final AsyncResponse asyncResponse, GameMessage gameMessage) {
    Future<Object> result = Patterns.ask(gamePlaySupervisor, gameMessage, 1000L);

    FutureConverters.toJava(result).toCompletableFuture()
        .thenApply(o -> {
            if (o instanceof Optional<?>) {
                Optional<Currency> optionalCurrency = (Optional<Currency>) o;
                if (optionalCurrency.isPresent()) {
                    log.debug("Returning currency result: {}", o);
                    return asyncResponse.resume(Response.ok().entity(((Optional<Currency>) o).get()).build());
                } else {
                    throw new NotFoundException("No player/currency found");
                }
            } else {
                log.warn("Unexpected result: {}", o);
                throw new InternalServerErrorException("Unexpected result");
            }
        })
        .exceptionally(asyncResponse::resume);
}

where you ask for response from an actor, the result is a scala Future which is needed to be converted to a java CompleteableFuture to create responses back to callers asynchronously.

Polyglot Approach

Finally, I want to show how you can use multiple languages in your project. You can take advantage of different programming languages on areas on your project where it makes a good fit. For my case, I used Spock that has nice syntax to better describe your tests. Spock is written in Groovy and uses language features to make it possible.

To use Groovy in your project just enable plugin:

plugins {
    id 'java'
    id 'groovy'

}

and for Spock bring these in to compile and test scopes:

dependencies {
    
    // Spock
    compile 'org.codehaus.groovy:groovy-all:2.4.10'
    testCompile 'org.spockframework:spock-core:1.1-groovy-2.4'
    testCompile 'org.spockframework:spock-spring:1.1-groovy-2.4'
    
}

Then you can write integration tests like:

def ".../currency should return ok for an existing player info"() {
    given:
        def pid = 1L
        def url = "/walletserver/players/${pid}/account/currency"
        def isoCurrencyCode = "SEK"
        def playerInfo = AccountingService.PlayerInfo.builder()
        .pid(pid)
        .isoCurrencyCode(isoCurrencyCode)
        .build()
        1 * accountingService.getPlayerInfo(pid) >> Optional.of(playerInfo)

    when:
        def entity =
                restTemplate.getForEntity(url, Currency.class)

    then:
        entity.statusCode == HttpStatus.OK
        entity.body.pid == pid
        entity.body.isoCurrencyCode == isoCurrencyCode
}

In Spock, you can use interpolated strings as the test fixture names and the given, when, then labels nicely express the intent how you want to test.

If you are interested more on the complete solution, source code can be found on Github

The core enabler of the solution is Apache PredictionIO which is an open source machine learning server built on top of a state-of-the-art open source stack for developers and data scientists to create predictive engines for any machine learning task.

You can install Apache PredictionIO on your machine as a full machine learning stack, bundled with Apache Spark, MLlib, HBase, Spray and Elasticsearch, which simplifies and accelerates scalable machine learning infrastructure management.

Using customizable templates, building and deploying a predictive engine is super easy.

As for my solution, I used a template for ranking products and adapted to my use case: In an online casino, a player is offered a ton of casino games and my aim is to be able to list relevant games to the player.

Once I train my model, I would be able to list games even if the player is a newly registered or I would rank games of a specific category of games thanks to the machine learning algorithm (ALS) behind.

Defining Model & Collecting Data

Now let’s talk a little about the data to train the algorithm.

We have two entities and one event which are Game, Player and Play Event respectively. Game represents a casino game with its id. Player is the customer of the online casino playing casino games, again represented with its id and the Play Event simply defines a game being played by a player at a certain time.

In online casino system collecting this info is no brainer. The only concern is how to import the data into the system. PredictionIO comes with a data store called Event Server which is backed by RDBMS (PostgreSQL and MySQL supported) or Elastic Search, HBase. Importing data is easy you can either use REST API or SDKs offered in Python, PHP, Ruby and Java.

Using Python SDK, I imported my events writing the script import_player_events.py:

python import_player_events.py --access_key <your access key>

where access_key is the key that is provided by PredictionIO for your predictive engine.

The important thing to note in here is that you need to define your model according to the algorithm you use for your engine.

Training the Model

Training is fairly easy with PredictionIO. All you need to run:

pio train

in your project folder.

Recommending Games

Once you trained your model and deployed your engine to PredictionIO you can retrieve recommended games by the query interface which is a REST endpoint of your engine. Later it can be utilized as a microservice integrated with the rest of your system.

Suppose you want to get recommended games for a given player. Just call the query endpoint with game ids like:

curl -H "Content-Type: application/json" \
-d '{ "player": 136286, "games": [0, 1, 2, 3, 4]}' \
http://localhost:8000/queries.json

The games will be sorted out in the response like:

{
  "gameScores": [
    {
      "game": 3,
      "score": 0.9574813396659806
    },
    {
      "game": 0,
      "score": 0.0016224116521859396
    },
    {
      "game": 1,
      "score": 0.0
    },
    {
      "game": 2,
      "score": 0.0
    },
    {
      "game": 4,
      "score": 0.0
    }
  ],
  "isOriginal": false
}

The games with higher scores are the ones you can display them to that specific player.

Check the project out in Github.

Database As Service 12c ile gelen bulut hizmetini verebilmek için olmazsa olmaz bir özellik olarak karşımıza çıkıyor. Veritabanını donanım, kurulum, yedekleme derdini düşünmeden basit bir hizmet satın almak da artık mümkün olabilir. Mesela bir Amazon Elastic Compute Cloud (EC2) servisi gibi internet üzerinde bir Oracle veri tabanı kiralayabiliriz. Etkinlikte daha çok private cloud’dan bahsedildi. İşin public tarafı ile ilgili ne tür opsiyonlar olduğundan çok bahsedilmedi.

Pluggable DB bir Oracle kurulumunda birbirinden tamamen bağımsız ve farklı şekilde yapılandırılabilen birden çok veritabanını çalıştırmayı mümkün kılacak bir teknoloji. Her bir veritabanı için ayrı kurulum olması zorunluluğu çok doğal değil. Yani ilişkisel veri tabanları konseptinde veritabanını da bir obje olarak düşünürsek, neden tek bir veritabanı engine’i aynı anda birden fazla veritabanına hizmet veremesin ki? Pluggable DB ile bu sorunun artık bir cevabı var.

In-Memory Option tablo, partition bazında tüm veya seçilen kolonları hafızaya alıp, veri tutarlılığını da koruyarak sorguları çok hızlı çalışmayı sağlayacak bir yenilik. Onu diğer cache çözümlerinden farklı kılan veriye her zaman en güncel hali ile erişimi sağlaması. Oracle’ın hafızasında (SGA) ayrı bir alan (Column Store) ayrılyor ve verinin en güncel halini “transaction commit” esnasında bu hafıza alanında da yazılıyor. Bu yeni hafıza alanında tablo satır bazlı değil kolon bazlı tutuluyor; böylelikle veriye erişim ve verinin hafızada kapladığı alanı optimum seviyeye çıkartılıyor. Netice itibariyle verinin analizine yönelik sorgularda doğru konfigurasyon yapılırsa sorgu hızında in-memory option’la 1000 kat ve belki daha fazla bir iyileşme yaşandığına dair örnek çalışmaların olduğu söyleniyor. Yalnız verinin devamlı güncellendiği (OLTP) durumda bu kadar hızlı sorgu performansı olmayacağı tabi ki eskisine oranla daha hızlı olacağını bekleyebiliriz.

Pattern Matching SQL dünyasında bir süredir beklenen veri üzerinde belli bir paterne uygun veriyi bulmayı kolaylaştıracak önemli bir özellik. Veriyi analiz ederken trend’leri belirlemek, anormal durumları tespit etmek, sahtekarlık/iç usulsüzlük tespiti tipik kullanım alanları arasında.

Aşağıda bunun nasıl kullanılabileceği ile ilgili bir sorgu örneğini görebiliriz.

Örnekte bir hesaptan para çekip (WTD) arada başka bir işlem olmaksızın parayı aynı hesaba geri yatıran (DEP) banka çalışanlarını tespit edecek bir sorgu verilmiştir. Banka çalışanının bir hesaptaki parayı zimmetine geçirip bir süre sonra aynı hesaba geri yatırması tespit edilmesi gereken şüpheli bir işlemdir.

Sql’in yapısına geçersek, SELECT ifadesinin sonuna MATCH_RECOGNIZE cümleciği koyarak başlıyoruz. Burada:

• PARTITION BY EMP ve ORDER BY TSTAMP kayıtlara çalışan bazında ve tarih sırasına göre erişmek istediğimizi,
• MEASURES alt cümleciği sorgu sonucunda pattern’e uyan hangi kolonları listeleyeceğimizi,
• ONE ROW PER MATCH pattern’e uyan tüm eşleşmeler için sadece bir kayıt dönmesini,
• PATTERN bu sorguda kullanmak istediğimiz pattern’i yani önce para çekme (WITHDRAW) sonra en azından bir para yatırmayı (DEPOSIT),
• DEFINE ise para çekme ve yatırmanın ne demek olduğunu

tanımlar.

Sorgunun kalan kısmında pattern’e uyan kayıtların aynı çalışan ve aynı hesap üzerinden yapılmış olması koşulunu içermektedir. Eşleşen kayıt sorgunun alt kısmında gösterilmiştir.

Örnekte de görüldüğü gibi MATCH_RECOGNIZE cümleciği ile okuması ve anlaşılması kolay sorgular yazabiliriz.

Oracle 12c veritabanı sistemi en azından bu yeni özelliği ile veri analizinde rakiplerinden bir adım öne çıkıyor.

Veri entegrasyonu konusunda çözüm sağlayıcılar daha çok kendilerine has yöntemler sunuyorlar ki genellikle bu ilişkisel veri tabanları üzerinden verinin paylaşılması veya içeri alınması şeklinde gerçekleniyor.

Bu yaklaşım hızlı bir şekilde projelerin ilerlemesini sağlayabilir. Ancak potansiyel olarak bir takım dezavantajlar barındırıyor:

1. Alternatif kaynaklardan veri aktarmak için ek çözümler gerekir. Bu durum rekabet anlamında çözüm sağlayıcıya zorluk yaşatacaktır. Diğer kaynakları kullanmak için ek geliştirmeye ihtiyaç duyulacaktır.
2. Hızlı (ve ucuz) çözümler tek bir müşteriye/duruma göre geliştirildiği için, entegrasyon alanı ile ilgili tüm durumları hesaba katarak geniş bir bakış açısıyla ele alamazlar. Bu yüzden beklenmedik sorunlarla her an karşılaşılabilir.
3. Çözüm sağlayıcı kendi geliştirdiği yöntem ile ilgili tüm sorunları tek başına çözmek durumundadır. Entegrasyon her yönüyle kompleks bir iştir. Kompleks problemlerle baş etmek için insan varoluşundan bu yana şablonları kullanagelmiştir. Tabi ki entegrasyon problemi için de bir takım entegrasyon şablonları geliştirilmiştir.

Apache Camel işte bu entegrasyon şablonlarını kullanarak, Java’da açık kaynaklı, neredeyse tüm entegrasyon ihtiyaçlarına cevap veren bir çözüm olarak kullanıma hazır olarak beklemektedir. Camel yukarıda bahsedilen sorunları basit bir şekilde adreslemektedir.

Camel veriyi hem tüketirken hem de üretirken farklı veri kaynakları ile birlikte bir arada kullanılabilir. Mesela HTTP client üzerinden toplanan bir veri dönüştürülüp doğrulandıktan sonra veritabanına yazılacak hale dönüştürülebilir. Camel ile böyle bir veri entegrasyonunu hiçbir geliştirme yapmadan gerçeklemek mümkündür. Aklınıza gelebilecek hemen hemen tüm veri entegrasyon noktaları uygun Camel bileşenleri (Camel Components) kullanılarak bağlanabilir.

Bunlardan bir kısmı:

• File (Dosya)
• HTTP
• FTP
• JMS
• JDBC

şeklinde sıralanabilir.

Bileşenler hem veri okurken (from) veya veriyi yazarken (to) kullanılabilir.

Camel bir Java kütüphanesi şeklinde mevcut uygulamalara eklenebildiği gibi, çok kullanılan Spring gibi framework’lerle de çalışabilecek şekilde tasarlanmıştır ve Spring’in XML konfigurasyon dosyasında veri entegrasyonu için gerekli konfigurasyon standart bileşenlerle hiç kod yazmadan yapılandırılabilir.

Camel veri çözümleri konusunda uygulama geliştiren çözüm üretecilerinin muhakkak değerlendirmeleri gereken önemli bir kaynaktır.

Hazırladığım ortam IntelliJ IDEA 11 + NodeJS Plugin ve NodeJS kurulularından oluşuyor.

IDEA javascript geliştirmek için piyasada olan en başarılı editor’lerden birini sağlıyor. Sadece kodu renklendirme, tamamlama değil bunun yanında JSHint’i de devreye alıp, javascript hatalarını ve doğru yazım kuralları konusunda da sizi uyarıyor.

NodeJS ile konunun ilintisi ise şuradan kaynaklanıyor: Javascript ile kodu yazarken herhangi bir kod parçasını anında çalıştırıp sonucunu görebilmeniz için önemli bir araç. Bunu IDE içerisinden çıkmadan yapabilmek size çok hız kazandıracağı için NodeJS’i IDEA içerisinden çalıştırabilmeniz gerekir. Onun için de Node JS Plugin’ini kurmalısınız.

Path To Node sizin makinenizdeki Node JS’in yerini ve Working Directory üzerinde çalıştığınız javascript dosyalarının olduğu yeri göstermeli. Path to Node App JS File‘ı girmediğiniz için size kızabilir ama dikkate almayın bunu. :)

Bundan sonra IDEA’da hazırladığımız Run/Debug Confguration’u olan NodeJS Interactive Shell’i (yukarıda bu ismi vermiştik) çalıştırıp, Run penceresinde denemelerinizi yapabilirsiniz.

Burada bahsetmem gereken bir konu daha var. Eğer hazırladığınız kodu bir NodeJS modülü haline getirirseniz tüm kodu Node’a yükleyebilir üzerinde oynayabilirsiniz. Node modülü haline getirmek için yapmanız gereken export’ları tanımlamak olacaktır. Buna ilaveten aşağıdaki gibi reload fonksiyonunu da eklerseniz kodu değiştirdikten sonra yeniden yükleyebilecek duruma da geleceksiniz.

Umarım yukarıda hızlıca bahsettiğim konfigurasyon başkalarının da işine yarar.

var ve val‘ı sadece değişkenleri tanımlarken değil aynı zamanda fonkisyon ve sınıf yapılandırıcıları (constructor) parametrelerini tanımlarken de kullanabilirsin. Bu durumda var ile tanımladığın parametreler fonksiyon ve yapılandırıcı içerisinde değiştirilebilirken, val ile tanımladıklarının sadece değerini okuyabilirsin.

Bunların yanında bir lazy val diye bir anahtar kelime daha var. Lazy isminden anlaşılabileceği veya programlamaya aşina olanlar için belli şimdi değil sonrayı çağrıştırıyor. Değişkenin değerini şimdi değil de sonra ata demek. Sonra ne zaman? İlk defa o değişkene kod çalışırken erişildiği zaman.

Yukarıda y değişkeni lazy val olarak tanımladık ve erişene kadar değer atamadığını görebiliyoruz. Yukarıdaki örneklerde atama yaparken { println("..."); ... } dikkatinizi çekmiştir. Scala’da kod blokları {...} arasında tanımlanır ve atama yaparken de bir kod bloğu kullanabilirsiniz.

val diye tanımladığımız değişkenler kod çalışırken en az bir kez yazılacak ve belki bir kere, on kere, yüz kere, bin kere okunacak belki de hiç okunmayacak(!). Madem okunmaya da bilir o zaman okunmayacak birşey okunana kadar atamazsak hafızayı daha az kullanmış oluruz. Onun için değişkeni lazy val ile tanımlayabiliriz. Bu yöntem hafıza kullanımı açısından faydalı olsa da cpu’yu normal bir atama gibi değil de daha fazla meşgul ediyor. Nedeni her erişimde en azından bir kez atama yapıldı mı yapılmadı mı diye kontrol etmek gerekiyor bir de ufak bir flag tutmak gerekir atandığını işaretlemek için. Bir de birden fazla thread bu değişkene erişebileceği için bu erişim kontrollü yapılması yani herhangi bir t anında sadece ve sadece bir thread’in erişmesi için gerekli senkronizasyonun işletilmesi gerekir.

Lazy’nin kullanılması gereken ilginç bir örnek vereyim:

B‘yi ilk kullanmaya çalıştığımızda NPE’yi yeriz. ;) Ama B‘yi şu şekilde tanımlarsak sorun olmaz:

Bunun nedeni A sınıfındaki x‘i B objesinde lazy olarak değiştirdik. Artık x‘e ilk erişildiğinde değeri atanacak. İlk erişildiği nokta ise A sınıfının başlangıcı (initialization’ı). İlk örnekte,x daha tanımlanmadığı için yani B objesi hafızada daha oluşturulmadan x‘e atama yapılmayacağı için null olarak kalacağından NPE oluşur.

Son olarak lazy’nin bir de döngüsel (cyclic) bağımlılıklarda nasıl işe yaradığını görelim ve macerayı tamamlayalım. Aşağıda birbirine bağımlı sınıf tanımları var:

B ve C sınıfları birbirine bağımlı. Bunların başlangıc kod bloklarında ki val x = ... kısmını lazy val x = ... şekline dönüştürmezsek StackOverflowError alırız. Lazy’yi bu örnekte olduğu gibi döngüsel bağımlılıklardan kaynaklanan durumları önlemek için de kullanabiliriz.

Burada herhangi tipteki nesneyi n kere çoğatıp sonunda o tipte bir liste üreten bir fonkisyon tanımı var.

Yukarıda bu fonksiyonu String tipinde bir nesne ile çağırdığımız zaman elde ettiğimiz sonucu görüyoruz. ;)

Fonksiyon ne yapıyor? n 0 olana dek x‘i bir listenin başına ekliyor. :: listeler için tanımlı ve elm :: list şeklinde kullanılan ve elemanı listenin başına eklemek için tanımlı bir operatördür. Yani:

En sondaki Nil‘e dikkat! Nil Java’cı biri için null‘sa haliyle bu NPE’ye neden olur diye düşündüm ilk olarak. Ama fonksiyon çalıştı. Nasıl? Demek ki Nil eşittir null doğru değil. Hadi diyelim Nil null değil. İyi de :: operatörü nasıl çalışıyor? O zaman type inference diye geçen, derleyicinin burada akıllı bir şekilde Nil’in boş bir liste olacağını anlayıp ona göre bir düzenleme yaptığı geldi aklıma. Ama o da değilmiş!

Scala API dokümanına bakınca, Nil’in boş bir List’e olduğunu gördüm:

Nothing?!! Nothing scala’da tanımlı tüm tiplerin alt tipiymiş. İyi de bu ne demek? Scala’da tüm tipler scala.Any tipinden geliyor. Java’daki java.lang.Object gibi. Any’nin iki direkt alt tipi var biri scala.AnyVal diğeri scala.AnyRef. İlki Java’daki int, double, float gibi sabit bir değer içeren tipleri, ikincisi de geri kalan diğer tüm tipleri ifade ediyor. Nothing‘in Any’den gelen diğer tüm tiplerin bir alt tipi olması demek Nothing herhangi tipe referans olarak kullanılabilir demek. Ne var ki Nothing tipinde bir nesne yaratmazsınız. Hiç/hiçlik bilinir ama gösterilemez yani ;)

List[Nothing] de bu durumda herhangi bir tipteki boş liste demektir. Çünkü hem Nothing tüm tiplerin alt tipidir hem de Nothing tipinde bir nesne olamayacağında göre liste boş olmak zorundadır. Bu yüzden de Nil‘in List[Nothing] olarak ifade edilmesi ve List[T] yani T tipindeki herhangi bir boş liste olması mantıklı hale gelmiş olur.

Yukarıdaki örnekteki f fonksiyonuna dikkat! Bu metodu hiçbir zaman çağıramazsınız. Zira çağıracak hiçi hiçbir zaman yaratamayacaksınız!

Nothing Scala’da hiç bitmesini istemediğimiz fonksiyonların dönüş tipi olarak kullanılır. Bir fonksiyonun dönüş tipi Nothing ise ve Nothing diye bir nesne üretemeyeceğimize göre bu fonksiyon bu tipte hiçbir değer üretemeyeceği için bitemeyecektir!

Nothing ile ilgili bir başka şey Null tipinin Nothing’den türemesidir. Null scala’da tanımlı bir başka tiptir ve sadece ama sadece bir objesi (instance’ı) vardır o da null’dur. null Java’daki null’un aynısıdır hiçbir nesneye referans olmayan bir değeri ifade etmek için kullanılır.

“Nil, Nothing, Null… Bunlara ne gerek vardı?”, “Java’daki gibi null neyinize yetmedi de bunları uydurdunuz?” diyebilirsiniz. Bunlar programlama mantığı açısından bakıldığında hem olması gereken yapılar hem de programlamada düşülen bazı tuzakları önlemek, programcının işini kolaylaştırmak adına iyi bir programlama dilinde olması gereken özellikler.

Bu kitapta şöyle bir ögüt vardı: “Her sene yeni bir programlama dili öğren!”. Nitekim o öğütü tuttum ve o günden sonra yeni dilleri öğrenmeye çalıştım. Python, erlang, javascript, ruby, smalltalk dillerini çalıştım. Öğrendiğim kadar da unutmuşluğum vardır. Ama yeni bir dile çalışmaya başlayınca programlamaya bakışın, problemlere çözümde yaklaşımın gelişiyor. Aradaki farkları, benzerlikleri görüyorsun; daha yukarıdan bakabiliyorsun. Bu dillerin bir de kendine ait felsefeleri var; anlamaya çalışıyorsun oradan yeni şeyler kapıyorsun. Kesinlikle tavsiye ediyorum herkese. Şöyle bir geçmişe dönüp bakınca bak .net’e (döt net) neden ilgi duymamışım diye de kendime soruyorum şimdi?!! Microsoft’a zamanında gıcıklığımızdan (bugün bunun çok da anlamlı olmadığını anlıyorum) belki uzak kaldım micro$oft’un sunduklarına.

Yeni bir programlama dili öğrenmek kolaydır aslında. İki haftada alışır birşeyler yapamaya muktedir olursun. Ama o dile tam anlamıyla hakim olmak bir seneni alır. O yüzden yavaş yavaş bıkmadan usanmadan; acele etmeden ağır ağır gideceksin. Scala çalışıyorum. Bu seneki dilim bu.

Scala hibrit bir dil. Hibrit? Yani hem fonksiyonel hem de nesneye dönelik yani yönelik :) Scala’nın daha ilginç yanı kendi derleyicisi var ama Java byte-code üretiyor. Yani JVM üzerinde çalışıyor. Java standart kütüphanesindeki sınıfları ve bilinen tüm Java kütüphanelerini direkt olarak kullanabiliyorsun. Yanında kendi kütüphanesi de var. Kendi kütüphanesi olması gerektiği gibi Java kütüphanesini tamamlıyor onu tekrarlamıyor.

Bugün linkedin, twitter ve foursquare gibi startup’ların kendi geliştirmeleri için kullanıyor olmasıyla popüler de oldu. Bilinen programlama dilleri listesinde de çok kullanılmasına göre 34. sıraya kadar da yükselmiş ve yine JVM üzerinde geliştirilmiş kendinden eski başka dilleri (mesela: Clojure, Groovy) de geçmiş durumda. Bu açıdan bakıldığında da kötü bir seçim değil yani.

Son olarak Scala ile ilgili olarak fonksiyonel programalama dili olması ve Java’nın sevilmeyen açıklarını kapaması gibi iki konuya değinmek istiyorum.

Fonksiyonel Programlama

Fonksiyonel programlama aslında uzun zamandır var olan bir programlama stili ve son yıllarda daha çok konuşulmaya başladı. Matematikteki fonksiyon mantığının programlamaya uyarlanmasıdır aslında. Bu programlamanın doğasına da tam oturur. Program dediğin netice itibariyle bir girdiyi alıp onu işleyip bir çıktı üreten şeydir yani bir fonksiyondur. Bir programın tüm parçalarını bu şekilde ifade edebilirsin. Program dediğin bir fonksiyonlar bütünüdür. Scala ile pür fonksiyonel programlama yapmak mümkündür.

Fonksiyonel programlama deyince tabi literatürde geçen “high order functions”, “no state preservation”, “clojure functions” gibi konulara da ileride değiniriz.

Scala aynı zamanda nesneye yönelik programlama için de gerekli olan yapıları barındırır. Bu onu hibrit yapan özelliğidir. Java gibi nesnel programlamaya aşina birine de Scala bu özelliğiyle kapıyı açık tutsa da kanımca, Scala’nın mucitleri o kafadakileri de fonksiyonel programlamaya devşirmek istemiş olabilirler.

Java’daki Eksiklikler

Java’nın eksiklerini tamamlaması ile ilgili olarak da Java’da çokça şikayet edilen primitive tipleri ortadan kaldırmasıyla dikkate şayandır. Bu şunun için önemlidir: Scala’da herşey nesnedir yani primitive tip yoktur. Bu da primitive’i nesneye, nesneyi primitive dönüştürmek gibi ameli işleri ortadan kaldırdığı gibi aynı zamanda temizlik anlamında da hoştur.

Bir başka konu “operator overloading” diye bilinen C++’çıların Java’da en çok istediği ve belki bu yüzden de çokça eleştirdiği Java’da olmayan bu özelliği eklemiş olmalarıdır. Yani siz herhangi yarattığınız bir tip (sınıf/class) için mesela “+” operatörünü tanımlayabilirsiniz. Yalnız single-inheritance hala var ama o da aslında olmasının bir programlama diline hayır getirdiği oldukça tartışmalı bir konu zaten.

Java’da sıklıkla kullanılan anonymous class’ları da fonksiyonlara havale ederek daha az kod yazarak aynı işi yapabilmesi de bir anlamda sentaks olarak bir temizlik, kolaylık getiriyor.

Scala ile ilgili maceraları daha sonraki yazılara havale ederek burada bitiriyorum. Yeni yılın ilk yazısı olması itibariyle de okuyan herkese iyi seneler dilerim. :)

Twitter sadece kişinin arkadaşları ve hatta tüm internet alemi ile her seferinde maksimum 140 harften oluşan mesajları paylaşabildiği sosyal bir ortam olması ötesinde; sağladığı alt yapı, ki kendisine “Application Programming Interface (API)” Türkçe olarak “Uygulama Programlama/Geliştirme Arayüzü” de denir, sayesinde kendi ekosistemini zenginleştirecek ek hizmetler geliştirilmesine izin vermektedir. Zaten akıllıca olanı da budur. Neden? Twitter ekosisteminde verilebilecek tüm hizmetleri kendisi yapamaz. Dolayısıyla başkalarının enerji ve yaratıcılığını kullanarak bir kazan-kazan durumu oluşturmak akıllıca bir davranış olur. Mesela, Microsoft’tan Windows işletim sistemi için yazılabilecek tüm programları sağlamasını bekler misiniz? Beklemeye beklersiniz de; Microsoft bunu yapmak ister mi? Konu anlaşıldı sanırım.

İyi de ne gibi uygulamalar geliştirilebilir? Twitter’ın web önyüzü dışında Windows, Mac için geliştirilmiş masaüstü uygulamalarını ilk çırpıda sayabiliriz. (bkz: 22 best twitter app) Veya web sitenize herhangi bir twitter kullanıcısını kabul edip, sitenizden twitter kullanıcısı adına mesela twit attırabilirsiniz. Onun da ötesinde Twitter’da var olan alt yapıyı zenginleştirecek uygulamalar geliştirilebilir. Örneğin bir süreliğine bazı takip ettiğiniz kişilerin twit’lerini görmek istemeyebilirsiniz (bkz: Twitter-DogHouse).

Örnekler uzatılabilir ama benim burada asıl anlatmak istediğim şey bir Twitter uygulamasını nasıl geliştireceğiniz konusunda bilgi vermek. Hadi başlayalım:

1. Yeni bir twitter hesabı açın: Geliştireceğiniz uygulama için bir twitter hesabı açmanız gerekir. Bu hesap, uygulamanızı twitter’a tanıtmak için gerekli olduğu gibi, aynı zamanda uygulamanızı kullanacak kişilerle yine twitter üzerinden haberleşmek imkanı tanıyacaktır. Bu kişiler uygulamanızı kullandıkları gibi twitter üzerinden sizin uygulamanızla ilgili bir takım güncel bilgileri paylaşmanızı sağlayabilir.

2. Uygulamanızı twitter’a kaydedin: Yeni açtığınız hesap ile giriş yaptıktan sonra uygulamanızı twitter ekosistemine ekleyin (bkz: yeni bir uygulama yaratmak). Burada uygulama ile ilgili resim, açıklama, web adresi gibi bilgiler yanında uygulamanın twitter kullanıcısı adına twit atmak, twit’lerine ulaşmak, direkt mesaj atmak gibi neler yapmak isteyeceğini belirtiyorsunuz. Uygulamanızı kaydettikten sonra API’yi kullanmaya başlayabilmeniz için gerekli olan tüketici anahtarı ve şifresi (consumer key & secret) veriliyor sistem tarafından.

3. Twitter API’sini öğrenin: Twitter API’si ile neler yapabileceğinizi öğrenin (bkz: Exploring the twitter API). Dokümanları karıştırın. Sizin öğrenme metodunuzu bilmem ama baştan sonra tüm dokümanları okumanızı tavsiye etmem. Herşeyi bir anda öğrenmeye kalkışmayın. Çabuk tükenirsiniz. Büyük resmi anlamaya çalışın, detaylara gerektiği zaman girersiniz. Üstelik herhangi bir konu kafanıza mı takıldı; hz. google’a sorun o sizi doğru yere yönlendirecektir. Sorunuzun cevabını bulamadığınız zaman stackoverflow ve twitter dev gruplarına (bkz: Twitter Dev Talk) sorun.

4. Twitter API’sini nasıl kullanacağınızı öğrenin: Uygulamanızı kullanacak olan twitter kullanıcıları adına API çağrıları yapmadan önce kullanıcıların size yetki vermesi gerekir. Twitter bunun için OAuth yetkilendirme mekanizmasını kullanmanızı şart koşuyor.

OAuth, Twitter gibi kullanıcıları adına işlem yaptıran platformlarda kullanılan güvenli ve standart bir yetkilendirme mekanizmasıdır. OAuth hiçbir şekilde kullanıcıların şifresini üçüncü partilerle paylaşmadığı için güvenlidir. OAuth standart olduğu için şimdiye kadar geliştirilmiş olan istemci kütüphanelerini (client libraries) uygulamanızda kullanabilir ve destek alabilirsiniz.

Twitter’da OAuth ile kullanıcı adına işlem yapabilmeniz için:

1. Erişim için bir anahtar almanız,
2. Tüm API çağrılarını aldığınız bu anahtar ile işaretlemeniz

gerekecektir.

Bunlar ile ilgili teknik detaylar için bkz: OAuth’u kullanmak.

Tabi hepsinden önce Twitter ekosistemine nasıl bir servis hazırlayarak katkıda bulunacağınızı bilmeniz gerekir. Bu sizin hayal gücünüze ve Twitter API’si ile neler yapabileceğinizi bilmenize kalıyor.