cryptocompress

"The basic idea is to have a Money class with fields for the numeric amount and the currency. You can store the amount as either an integral type or a fixed decimal type. The decimal type is easier for some manipulations, the integral for others. You should absolutely avoid any kind of floating point type, as that will introduce the kind of rounding problems that Money is intended to avoid. Most of the time people want monetary values rounded to the smallest complete unit, such as cents in the dollar. However, there are times when fractional units are needed. It’s important to make it clear what kind of money you’re working with, especially in an application that uses both kinds. It makes sense to have different types for the two cases as they behave quite differently under arithmetic.

Money needs arithmetic operations so that you can use money objects as easily as you use numbers. But arithmetic operations for money have some important differences to money operations in numbers. Most obviously, any addition or

garcia-jj

package br.com.caelum.vraptor.benchmark;

import java.lang.invoke.MethodHandle;
import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;

import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;

plentz

# to generate your dhparam.pem file, run in the terminal
openssl dhparam -out /etc/nginx/ssl/dhparam.pem 2048

guilhermesilveira

public class ApplicationHelper implements ViewHelper {
  
	private final PrettyTimeFormatter formatter;

	public ApplicationHelper(PrettyTimeFormatter formatter) {
		this.formatter = formatter;
	}
	
	public String format(AbstractInstant instant) {
		return formatter.format(instant);

marceloemanoel

package br.com.smartcoders.easyclinic.components;

import org.springframework.http.HttpStatus;

import br.com.caelum.vraptor.Intercepts;
import br.com.caelum.vraptor.Result;
import br.com.caelum.vraptor.InterceptionException;
import br.com.caelum.vraptor.core.InterceptorStack;
import br.com.caelum.vraptor.interceptor.Interceptor;
import br.com.caelum.vraptor.interceptor.ParametersInstantiatorInterceptor;

juanplopes

#!/usr/bin/env python
import httplib, getpass, base64, json, datetime, sys, xml.etree.ElementTree as ET, os.path as path, os

KEY = 'your-private-repo'
NS = {'n':'http://maven.apache.org/SETTINGS/1.0.0'}

def make_auth(username, password):
    return base64.b64encode('{}:{}'.format(username, password))

def make_token(repokey, username, password):

danmikita

Git Push Deployments

Some Background Information

In git, a tag (like many other things) is what's called a treeish. It's a way of referring to a point in the history of the project. Treeishes can be a tag, a commit, a date specifier, an ordinal specifier or many other things. A branch is just like a tag but is movable. When you are on a branch and make a commit, the branch is moved to the new commit you made indicating it's current position.

Your HEAD is a pointer to a branch which is considered "current". Usually when you clone a repository, HEAD will point to master which in turn will point to a commit. When you then do something like git checkout experimental, you switch the HEAD to point to the experimental branch, which might point to a different commit.

When you do a git checkout v2.0 (v2.0 in this case is a tag), you are switching to a commit that is not pointed to by a branch. The HEAD is now "detached" and not po

jeremyjarrell

DELIMITER $$

DROP PROCEDURE IF EXISTS add_email_address_column_to_customers_table $$

-- Create the stored procedure to perform the migration
CREATE PROCEDURE add_email_address_column_to_customers_table()

BEGIN
  
  -- Add the email_address column to the customers table, if it doesn't already exist

jeremyjarrell

<project name="migrations">

  <target name="prefix-new-migrations">
  	<foreach target="rename-file" param="the-file">
			<path>
        <!-- The hardcoded directory containing the migrations -->
				<fileset dir="./src/db/migrations" casesensitive="no" includes="*.sql">
          <!-- Exclude any migration files which have already been prefixed -->
					<not>
    					<filename regex="\d+__.*" casesensitive="true"/>

blaix

On Tue, Mar 12, 2013 at 1:26 PM, Martin Fowler [email protected] wrote:

The term pops up in some different places, so it's hard to know what it means without some context. In PoEAA I use the pattern Service Layer to represent a domain-oriented layer of behaviors that provide an API for the domain layer. This may or may not sit on top of a Domain Model. In DDD Eric Evans uses the term Service Object to refer to objects that represent processes (as opposed to Entities and Values). DDD Service Objects are often useful to factor out behavior that would otherwise bloat Entities, it's also a useful step to patterns like Strategy and Command.

It sounds like the DDD sense is the sense I'm encountering most often. I really need to read that book.

The conceptual problem I run into in a lot of codebases is that rather than representing a process, the "service objects" represent "a thing that does the process". Which sounds like a nitpicky difference, but it seems to have a real impact on how people us