text:
![test](https://github.com/JuliaInterop/CxxWrap.jl/workflows/test/badge.svg)

This package aims to provide a Boost.Python-like wrapping for C++ types and functions to Julia.
The idea is to write the code for the Julia wrapper in C++, and then use a one-liner on the Julia side to make the wrapped C++ library available there.

The mechanism behind this package is that functions and types are registered in C++ code that is compiled into a dynamic library.
This dynamic library is then loaded into Julia, where the Julia part of this package uses the data provided through a C interface to generate functions accessible from Julia.
The functions are passed to Julia either as raw function pointers (for regular C++ functions that  don't need argument or return type conversion) or std::functions (for lambda expressions and automatic conversion of arguments and return types).
The Julia side of this package wraps all this into Julia methods automatically.

For this to work, the user must have a C++ compiler installed which supports C++17
(e.g. GCC 7, clang 5; for macOS users that means Xcode 9.3).

## What's the difference with Cxx.jl?
With [Cxx.jl](https://github.com/Keno/Cxx.jl/) it is possible to directly access C++ using the `@cxx` macro from Julia.
So when facing the task of wrapping a C++ library in a Julia package, authors now have two options:
* Use Cxx.jl to write the wrapper package in Julia code (much like one uses `ccall` for wrapping a C library)
* Use CxxWrap to write the wrapper completely in C++ (and one line of Julia code to load the .so)

Boost.Python also uses the latter (C++-only) approach, so translating existing Python bindings based on Boost.Python may be easier using CxxWrap.

## Features
* Support for C++ functions, member functions and lambdas
* Classes with single inheritance, using abstract base classes on the Julia side
* Trivial C++ classes can be converted to a Julia isbits immutable
* Template classes map to parametric types, for the instantiations listed in the wrapper
* Automatic wrapping of default and copy constructor (mapped to `copy`) if defined on the wrapped C++ class
* Facilitate calling Julia functions from C++

## Installation
Just like any registered package, in pkg mode (`]` at the REPL)
```julia
add CxxWrap
```

CxxWrap v0.10 and later depends on the `libcxxwrap_julia_jll` [JLL package](https://julialang.org/blog/2019/11/artifacts/) to manage the `libcxxwrap-julia` binaries. See the [libcxxwrap-julia Readme](https://github.com/JuliaInterop/libcxxwrap-julia) for information on how to build this library yourself and force CxxWrap to use your own version.

## Boost Python Hello World example
Let's try to reproduce the example from the [Boost.Python tutorial](http://www.boost.org/doc/libs/1_59_0/libs/python/doc/tutorial/doc/html/index.html).
Suppose we want to expose the following C++ function to Julia in a module called `CppHello`:
```c++
std::string greet()
{
   return "hello, world";
}
```
Using the C++ side of `CxxWrap`, this can be exposed as follows:
```c++
#include "jlcxx/jlcxx.hpp"

JLCXX_MODULE define_julia_module(jlcxx::Module& mod)
{
  mod.method("greet", &greet);
}
```

Once this code is compiled into a shared library (say `libhello.so`) it can be used in Julia as follows:

```julia
# Load the module and generate the functions
module CppHello
  using CxxWrap
  @wrapmodule(joinpath("path/to/built/lib","libhello"))

  function __init__()
    @initcxx
  end
end

# Call greet and show the result
@show CppHello.greet()
```
The code for this example can be found in [`hello.cpp`] in the [examples directory of the `libcxxwrap-julia` project](https://github.com/JuliaInterop/libcxxwrap-julia/tree/master/examples) and [`test/hello.jl`](test/hello.jl).
Note that the `__init__` function is necessary to support precompilation, which is on by default since Julia 1.0.

## Compiling the C++ code
The recommended way to compile the C++ code is to use CMake to discover `libcxxwrap-julia` and the Julia libraries.
A full example is in the [`testlib` directory of `libcxxwrap-julia`](https://github.com/JuliaInterop/libcxxwrap-julia/tree/master/testlib-builder/src/testlib).
The following sequence of commands can be used to build:

```bash
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH=/path/to/libcxxwrap-julia-prefix /path/to/sourcedirectory
cmake --build . --config Release
```

The path for `CMAKE_PREFIX_PATH` can be obtained from Julia using:

```julia
julia> using CxxWrap
julia> CxxWrap.prefix_path()
```

### Windows and MSVC
The default binaries installed with CxxWrap are cross-compiled using GCC, and thus incompatible with Visual Studio C++ (MSVC).
In MSVC 2019, it is easy to check out `libcxxwrap-julia` from git, and then build it and the wrapper module from source.
Details are provided in the [README](https://github.com/JuliaInterop/libcxxwrap-julia#building-on-windows).

## Module entry point

Above, we defined the module entry point as a function `JLCXX_MODULE define_julia_module(jlcxx::Module& mod)`.
In the general case, there may be multiple modules defined in a single library, and each should have its own entry point, called within the appropriate module:

```c++
JLCXX_MODULE define_module_a(jlcxx::Module& mod)
{
  // add stuff for A
}

JLCXX_MODULE define_module_b(jlcxx::Module& mod)
{
  // add stuff for B
}
```

In Julia, the name of the entry point must now be specified explicitly:

```julia
module A
  using CxxWrap
  @wrapmodule("mylib.so",:define_module_a)
end

module B
  using CxxWrap
  @wrapmodule("mylib.so",:define_module_b)
end
```

In specific cases, it may also be necessary to specify `dlopen` flags such as `RTLD_GLOBAL`.
These can be supplied in a third, optional argument to `@wrapmodule`, e.g:

```julia
@wrapmodule(CxxWrapCore.libcxxwrap_julia_stl, :define_cxxwrap_stl_module, Libdl.RTLD_GLOBAL)
```

## More extensive example and function call performance
A more extensive example, including wrapping a C++11 lambda and conversion for arrays can be found in [`examples/functions.cpp`](https://github.com/JuliaInterop/libcxxwrap-julia/tree/master/examples/functions.cpp) and [`test/functions.jl`](test/functions.jl).
This test also includes some performance measurements, showing that the function call overhead is the same as using `ccall` on a C function if the C++ function is a regular function and does not require argument conversion.
When `std::function` is used (e.g. for C++ lambdas) extra overhead appears, as expected.

## Exposing classes

Consider the following C++ class to be wrapped:

```c++
struct World
{
  World(const std::string& message = "default hello") : msg(message){}
  void set(const std::string& msg) { this->msg = msg; }
  std::string greet() { return msg; }
  std::string msg;
  ~World() { std::cout << "Destroying World with message " << msg << std::endl; }
};
```

Wrapped in the entry point function as before and defining a module `CppTypes`, the code for exposing the type and some methods to Julia is:

```c++
types.add_type<World>("World")
  .constructor<const std::string&>()
  .method("set", &World::set)
  .method("greet", &World::greet);
```

Here, the first line just adds the type.
The second line adds the non-default constructor taking a string.
Finally, the two `method` calls add member functions, using a pointer-to-member.
The member functions become free functions in Julia, taking their object as the first argument.
This can now be used in Julia as

```julia
w = CppTypes.World()
@test CppTypes.greet(w) == "default hello"
CppTypes.set(w, "hello")
@test CppTypes.greet(w) == "hello"
```

The manually added constructor using the `constructor` function also creates a finalizer.
This can be disabled by adding the argument `false`:

```c++
types.add_type<World>("World")
  .constructor<const std::string&>(false);
```

The `add_type` function actually builds two Julia types related to `World`.
The first is an abstract type:

```julia
abstract type World end
```

The second is a mutable type (the "allocated" or "boxed" type) with the following structure:

```julia
mutable struct WorldAllocated <: World
  cpp_object::Ptr{Cvoid}
end
```

This type needs to be mutable, because it must have a finalizer attached to it that deletes the held C++ object.

This means that the variable `w` in the above example is of concrete type `WorldAllocated` and letting it go out of scope may trigger the finalizer and delete the object.
When calling a C++ constructor, it is the responsibility of the caller to manage the lifetime of the resulting variable.

The above types are used in method generation as follows, considering for example the greet method taking a `World` argument:

```julia
greet(w::World) = ccall($fpointer, Any, (Ptr{Cvoid}, WorldRef), $thunk, cconvert(WorldRef, w))
```

Here, the `cconvert` from `WorldAllocated` to `WorldRef` is defined automatically when creating the type.

**Warning:** The ordering of the C++ code matters: types used as function arguments or return types must be added before they are used in a function.

The full code for this example and more info on immutables and bits types can be found in [`examples/types.cpp`](https://github.com/JuliaInterop/libcxxwrap-julia/tree/master/examples/types.cpp) and [`test/types.jl`](test/types.jl).

### Checking for null

Values returned from C++ can be checked for being null using the `isnull` function.

## Setting the module to which methods are added

It is possible to add methods directly to e.g. the Julia `Base` module, using `set_override_module`.
After calling this, all methods will be added to the specified module.
To revert to the default behavior of adding methods to the current module, call `unset_override_module`.

```c++
mod.add_type<A>("A", jlcxx::julia_type("AbstractFloat", "Base"))
    .constructor<double>();
mod.set_override_module(mod.julia_module());
// == will be in the wrapped module:
mod.method("==", [](A& a, A& b) { return a == b; });
mod.set_override_module(jl_base_module);
// The following methods will be in Base
mod.method("+", [](A& a, A& b) { return a + b; });
mod.method("float", [](A& a) { return a.get_val(); });
// Revert to default behavior
mod.unset_override_module();
mod.method("val", [](A& a) { return a.get_val(); });
```

## Inheritance
To encapsulate inheritance, types must first inherit from each other in C++, so a `static_cast` to the base type can work:

```c++
struct A
{
  virtual std::string message() const = 0;
  std::string data = "mydata";
};

struct B : A
{
  virtual std::string message() const
  {
    return "B";
  }
};
```

When adding the type, add the supertype as a second argument:

```c++
types.add_type<A>("A").method("message", &A::message);
types.add_type<B>("B", jlcxx::julia_base_type<A>());
```

The supertype is of type `jl_datatype_t*` and using the template function `jlcxx::julia_base_type` looks up the abstract type associated with `A` here.
Since the concrete arguments given to `ccall` are the reference types, we need a way to convert `BRef` into `ARef`.
To allow CxxWrap to figure out the correct static_cast to use, the hierarchy must be defined at compile time as follows:

```c++
namespace jlcxx
{
  template<> struct SuperType<B> { typedef A type; };
}
```

There is also a variant taking a string for the type name and an optional Julia module name as second argument, which is useful for inheriting from a type defined in Julia, e.g.:

```c++
mod.add_type<Teuchos::ParameterList>("ParameterList", jlcxx::julia_type("AbstractDict", "Base"))
```

The value returned by `add_type` also had a `dt()` method, useful in the case of template types:

```c++
auto multi_vector_base = mod.add_type<Parametric<TypeVar<1>>>("MultiVectorBase");
auto vector_base = mod.add_type<Parametric<TypeVar<1>>>("VectorBase", multi_vector_base.dt());
```

See the test at [`examples/inheritance.cpp`](https://github.com/JuliaInterop/libcxxwrap-julia/tree/master/examples/inheritance.cpp) and [`test/inheritance.jl`](test/inheritance.jl).

## Enum types

Enum types are converted to strongly-typed bits types on the Julia side.
Consider the C++ enum:

```c++
enum MyEnum
{
  EnumValA,
  EnumValB
};
```

This is registered as follows:

```c++
JLCXX_MODULE define_types_module(jlcxx::Module& types)
{
  types.add_bits<MyEnum>("MyEnum", jlcxx::julia_type("CppEnum"));
  types.set_const("EnumValA", EnumValA);
  types.set_const("EnumValB", EnumValB);
}
```

The enum constants will be available on the Julia side as `CppTypes.EnumValA` and `CppTypes.EnumValB`, both of type `CppTypes.MyEnum`.
Wrapped C++ functions taking a `MyEnum` will only accept a value of type `CppTypes.MyEnum` in Julia.

## Template (parametric) types

The natural Julia equivalent of a C++ template class is the parametric type.
The mapping is complicated by the fact that all possible parameter values must be compiled in advance, requiring a deviation from the syntax for adding a regular class.
Consider the following template class:

```c++
template<typename A, typename B>
struct TemplateType
{
  typedef typename A::val_type first_val_type;
  typedef typename B::val_type second_val_type;

  first_val_type get_first()
  {
    return A::value();
  }

  second_val_type get_second()
  {
    return B::value();
  }
};
```

The code for wrapping this is:

```c++
types.add_type<Parametric<TypeVar<1>, TypeVar<2>>>("TemplateType")
  .apply<TemplateType<P1,P2>, TemplateType<P2,P1>>([](auto wrapped)
{
  typedef typename decltype(wrapped)::type WrappedT;
  wrapped.method("get_first", &WrappedT::get_first);
  wrapped.method("get_second", &WrappedT::get_second);
});
```

The first line adds the parametric type, using the generic placeholder `Parametric` and a `TypeVar` for each parameter.
On the second line, the possible instantiations are created by calling `apply` on the result of `add_type`.
Here, we allow for `TemplateType<P1,P2>` and `TemplateType<P2,P1>` to exist, where `P1` and `P2` are C++ classes that also must be wrapped and that fulfill the requirements for being a parameter to `TemplateType`.
The argument to `apply` is a functor (generic C++14 lambda here) that takes the wrapped instantiated type (called `wrapped` here) as argument.
This object can then be used as before to define methods.
In the case of a generic lambda, the actual type being wrapped can be obtained using `decltype` as shown on the 4th line.

Use on the Julia side:

```julia
import ParametricTypes.TemplateType, ParametricTypes.P1, ParametricTypes.P2

p1 = TemplateType{P1, P2}()
p2 = TemplateType{P2, P1}()

@test ParametricTypes.get_first(p1) == 1
@test ParametricTypes.get_second(p2) == 1
```

There is also an `apply_combination` method to make applying all combinations of parameters shorter to write.

Full example and test including non-type parameters at: [`examples/parametric.cpp`](https://github.com/JuliaInterop/libcxxwrap-julia/tree/master/examples/parametric.cpp) and [`test/parametric.jl`](test/parametric.jl).

## Constructors and destructors

The default constructor and any manually added constructor using the `constructor` function will automatically create a Julia object that has a finalizer attached that calls delete to free the memory.
To write a C++ function that returns a new object that can be garbage-collected in Julia, use the `jlcxx::create` function:

```c++
jlcxx::create<Class>(constructor_arg1, ...);
```

This will return the new C++ object wrapped in a `jl_value_t*` that has a finalizer.

### Copy contructor

The copy constructor is mapped to Julia's standard `copy` function. Using the `.`-notation it can be used to easily create a Julia arrays from the elements of e.g. an `std::vector`:

```julia
wvec = cpp_function_returning_vector()
julia_array = copy.(wvec)
```

## Call operator overload

Since Julia supports overloading the function call operator `()`, this can be used to wrap `operator()` by just omitting the method name:

```c++
struct CallOperator
{
  int operator()() const
  {
    return 43;
  }
};

// ...

types.add_type<CallOperator>("CallOperator").method(&CallOperator::operator());
```

Use in Julia:

```julia
call_op = CallOperator()
@test call_op() == 43
```

The C++ function does not even have to be `operator()`, but of course it is most logical use case.

## Automatic argument conversion

By default, overloaded signatures for wrapper methods are generated, so a method taking a `double` in C++ can be called with e.g. an `Int` in Julia.
Wrapping a function like this:

```c++
mod.method("half_lambda", [](const double a) {return a*0.5;});
```

then yields the methods:

```julia
half_lambda(arg1::Int64)
half_lambda(arg1::Float64)
```

In some cases (e.g. when a template parameter depends on the number type) this is not desired, so the behavior can be disabled on a per-argument basis using the `StrictlyTypedNumber` type.
Wrapping a function like this:

```c++
mod.method("strict_half", [](const jlcxx::StrictlyTypedNumber<double> a) {return a.value*0.5;});
```

will *only* yield the Julia method:

```julia
strict_half(arg1::Float64)
```

Note that in C++ the number value is accessed using the `value` member of `StrictlyTypedNumber`.

### Customization

The automatic overloading can be customized.
For example, to allow passing an `Int64` where a `UInt64` is normally expected, the following method can be added:

```julia
CxxWrap.argument_overloads(t::Type{UInt64}) = [Int64]
```

## Integer types

Due to the fact that built-in integer types don't have an imposed size, they can't be mapped to Julia integer types in the same way on every platform. For CxxWrap, we take the following approach:
* Fixed-size types such as `int32_t` are mapped directly to their Julia equivalents
* Built-in types are mapped to a named type, e.g. the C++ type `long` becomes `CxxLong` in Julia. If in the given C++ implementation we have `long == int64_t`, then in Julia `CxxLong` will be an alias for `Int64`, otherwise it is its own bits type.

The following table gives an overview of the mapping, where some of the `Cxx*` types may actually be aliases for a Julia type:

| C++                | Julia              |
| -------------------|--------------------|
|`int8_t`            |`Int8`              |
|`uint8_t`           |`UInt8`             |
|`int16_t`           |`Int16`             |
|`uint16_t`          |`UInt16`            |
|`int32_t`           |`Int32`             |
|`uint32_t`          |`UInt32`            |
|`int64_t`           |`Int64`             |
|`uint64_t`          |`UInt64`            |
|`bool`              |`CxxBool`           |
|`char`              |`CxxChar`           |
|`wchar_t`           |`CxxWchar`          |
|`signed char`       |`CxxSignedChar`     |
|`unsigned char`     |`CxxUChar`          |
|`short`             |`CxxShort`          |
|`unsigned short`    |`CxxUShort`         |
|`int`               |`CxxInt`            |
|`unsigned int`      |`CxxUInt`           |
|`long`              |`CxxLong`           |
|`unsigned long`     |`CxxULong`          |
|`long long`         |`CxxLongLong`       |
|`unsigned long long`|`CxxULongLong`      |

## Pointers and references

Simple pointers and references are treated the same way, and wrapped in a struct with as a single member the pointer to the C++ object.

### References to pointers

A reference to a pointer allows changing the referred object, e.g.:

```c++
void writepointerref(MyData*& ptrref)
{
  delete ptrref;
  ptrref = new MyData(30);
}
```

is called from Julia as:

```julia
d = PtrModif.MyData()
writepointerref(Ref(d))
```

Note that this modifies `d` itself, so `d` must be a `MyDataAllocated`.
More details are in the `pointer_modification` example.

### Reference to `bool`

In the Julia C calling convention, a boolean is a `Cuchar`, so to pass a reference to a boolean to C++ you need:

```julia
bref = Ref{Cuchar}(0)
boolref(bref)
```

Where `boolref` on the C++ side is:

```c++
mod.method("boolref", [] (bool& b)
{
  b = !b;
});
```

Strictly speaking, the representation of `bool` in C++ is implementation-defined, so this conversion relies on undefined behavior. Passing references to boolean is therefore not recommended, it is better to sidestep this by writing e.g. a wrapper function in C++ that returns a boolean by value.

### Smart pointers

Currently, `std::shared_ptr`, `std::unique_ptr` and `std::weak_ptr` are supported transparently.
Returning one of these pointer types will return an object inheriting from `SmartPointer{T}`:

```c++
types.method("shared_world_factory", []()
{
  return std::shared_ptr<World>(new World("shared factory hello"));
});
```

The shared pointer can then be used in a function taking an object of type `World` like this (the module is named `CppTypes` here):

```julia
swf = CppTypes.shared_world_factory()
CppTypes.greet(swf)
```

Explicit dereferencing is also supported, using the `[]` operator:

```julia
CppTypes.greet(swf[])
```

#### Adding a custom smart pointer

Suppose we have a "smart" pointer type defined as follows:

```c++
template<typename T>
struct MySmartPointer
{
  MySmartPointer(T* ptr) : m_ptr(ptr)
  {
  }

  MySmartPointer(std::shared_ptr<T> ptr) : m_ptr(ptr.get())
  {
  }

  T& operator*() const
  {
    return *m_ptr;
  }

  T* m_ptr;
};
```

Specializing in the `jlcxx` namespace:

```c++
namespace jlcxx
{
  template<typename T> struct IsSmartPointerType<cpp_types::MySmartPointer<T>> : std::true_type { };
  template<typename T> struct ConstructorPointerType<cpp_types::MySmartPointer<T>> { typedef std::shared_ptr<T> type; };
}
```

Here, the first line marks our type as a smart pointer, enabling automatic conversion from the pointer to its referenced type and adding the dereferencing pointer.
If the type uses inheritance and the hierarchy is defined using `SuperType`, automatic conversion to the pointer or reference of the base type is also supported.
The second line indicates that our smart pointer can be constructed from a `std::shared_ptr`, also adding auto-conversion for that case.
This is useful for a relation as in `std::weak_ptr` and `std::shared_ptr`, for example.

## Function arguments

Because C++ functions often return references or pointers, writing Julia functions that operate on C++ types can be tricky.
For example, writing a function like:

```julia
julia_greet(w::World) = greet_cpp(w)
```

If `World` is a type from C++, this will only work with objects that have been constructed directly or that were returned by value from C++.
To make it work with references and pointers, we would need an additional method:

```julia
julia_greet(w::CxxWrap.CxxBaseRef{World}) = greet_cpp(w[])
```

Note that in the general case, both the signature and the implementation need to change, making this cumbersome when there are many functions like this.
Enter the `@cxxdereference` macro.
Declaring the function like this makes sure it can accept both values and references:

```julia
@cxxdereference julia_greet(w::World) = greet_cpp(w)
```

The `@cxxdereference` macro changes the function into:

```julia
function julia_greet(w::CxxWrap.reference_type_union(World))
    w = CxxWrap.dereference_argument(w)
    greet_cpp(w)
end
```

The type of `w` is now calculated by the `CxxWrap.reference_type_union` function, which resolves to `Union{World, CxxWrap.CxxBaseRef{World}, CxxWrap.SmartPointer{World}}`.
The behavior of the macro can be customized by adding methods to `CxxWrap.reference_type_union` and `CxxWrap.dereference_argument`.

## Exceptions

When directly adding a regular free C++ function as a method, it will be called directly using `ccall` and any exception will abort the Julia program.
To avoid this, you can force wrapping it in an `std::function` to intercept the exception automatically by setting the `force_convert` argument to `method` to true:

```c++
mod.method("test_exception", test_exception, true);
```

Member functions and lambdas are automatically wrapped in an `std::function` and so any exceptions thrown there are always intercepted and converted to a Julia exception.

## Tuples

C++11 tuples can be converted to Julia tuples by including the `containers/tuple.hpp` header:

```c++
#include "jlcxx/jlcxx.hpp"
#include "jlcxx/tuple.hpp"

JLCXX_MODULE define_types_module(jlcxx::Module& containers)
{
  containers.method("test_tuple", []() { return std::make_tuple(1, 2., 3.f); });
}
```

Use in Julia:

```julia
using CxxWrap
using Base.Test

module Containers
  @wrapmodule(libcontainers)
  export test_tuple
end
using Containers

@test test_tuple() == (1,2.0,3.0f0)
```

## Working with arrays

### Reference native Julia arrays

The `ArrayRef` type is provided to work conveniently with array data from Julia.
Defining a function like this in C++:

```c++
void test_array_set(jlcxx::ArrayRef<double> a, const int64_t i, const double v)
{
  a[i] = v;
}
```

This can be called from Julia as:

```julia
ta = [1.,2.]
test_array_set(ta, 0, 3.)
```

The `ArrayRef` type provides basic functionality:
* iterators
* `size`
* `[]` read-write accessor
* `push_back` for appending elements

Note that `ArrayRef` only works with primitive types, if you need a "boxed" type it has to be made an array of `Any` with type `ArrayRef<jl_value_t*>` in C++.

### Const arrays

Sometimes, a function returns a `const` pointer that is an array, either of fixed size or with a size that can be determined from elsewhere in the API.
Example:

```c++
const double* const_vector()
{
  static double d[] = {1., 2., 3};
  return d;
}
```

In this simple case, the most logical way to translate this would be as a tuple:

```c++
mymodule.method("const_ptr_arg", []() { return std::make_tuple(const_vector().ptr[0], const_vector().ptr[1], const_vector().ptr[2]); });
```

In the case of a larger blob of heap-allocated data it makes more sense to convert this to a `ConstArray`, which implements the read-only part of the Julia array interface, so it exposes the data safely to Julia in a way that can be used natively:

```c++
mymodule.method("const_vector", []() { return jlcxx::make_const_array(const_vector(), 3); });
```

For multi-dimensional arrays, the `make_const_array` function takes multiple sizes, e.g.:

```c++
const double* const_matrix()
{
  static double d[2][3] = {{1., 2., 3}, {4., 5., 6.}};
  return &d[0][0];
}

// ...module definition skipped...

mymodule.method("const_matrix", []() { return jlcxx::make_const_array(const_matrix(), 3, 2); });
```

Note that because of the column-major convention in Julia, the sizes are in reversed order from C++, so the Julia code:

```julia
display(const_matrix())
```

shows:

```
3x2 ConstArray{Float64,2}:
 1.0  4.0
 2.0  5.0
 3.0  6.0
```
An extra file has to be included to have constant array functionality: `#include "jlcxx/const_array.hpp"`.

### Mutable arrays

Replacing `make_const_array` in the examples above by `make_julia_array` creates a mutable, regular Julia array with memory owned by C++.

## Calling Julia functions from C++

### Direct call to Julia

Directly calling Julia functions uses `jl_call` from `julia.h` but with a more convenient syntax and automatic argument conversion and boxing.
Use a `JuliaFunction` to get a functor that can be invoked directly.
Example for calling the `max` function from `Base`:

```c++
mymodule.method("julia_max", [](double a, double b)
{
  jlcxx::JuliaFunction max("max");
  return max(a, b);
});
```

Internally, the arguments and return value are boxed, making this method convenient but slower than calling a regular C function.

### Safe `cfunction`

The macro `CxxWrap.@safe_cfunction` provides a wrapper around `Base.@cfunction` that checks the type of the function pointer.
Example C++ function:

```c++
mymodule.method("call_safe_function", [](double(*f)(double,double))
{
  if(f(1.,2.) != 3.)
  {
    throw std::runtime_error("Incorrect callback result, expected 3");
  }
});
```

Use from Julia:

```julia
testf(x,y) = x+y
c_func = @safe_cfunction(testf, Float64, (Float64,Float64))
MyModule.call_safe_function(c_func)
```

Using types different from the expected function pointer call will result in an error.
This check incurs a runtime overhead, so the idea here is that the function is converted only once and then applied many times on the C++ side.

If the result of `@safe_cfunction` needs to be stored before the calling signature is known, direct conversion of the created structure (type `SafeCFunction`) is also possible.
It can then be converted later using `jlcxx::make_function_pointer`:

```c++
mymodule.method("call_safe_function", [](jlcxx::SafeCFunction f_data)
{
  auto f = jlcxx::make_function_pointer<double(double,double)>(f_data);
  if(f(1.,2.) != 3.)
  {
    throw std::runtime_error("Incorrect callback result, expected 3");
  }
});
```

This method of calling a Julia function is less convenient, but the call overhead should be no larger than calling a regular C function through its pointer.

## Adding Julia code to the module

Sometimes, you may want to write additional Julia code in the module that is built from C++.
To do this, call the `wrapmodule` method inside an appropriately named Julia module:

```julia
module ExtendedTypes

using CxxWrap
@wrapmodule("libextended")
export ExtendedWorld, greet

end
```

Here, `ExtendedTypes` is a name that matches the module name passed to `create_module` on the C++ side.
The `@wrapmodule` call works as before, but now the functions and types are defined in the existing `ExtendedTypes` module, and additional Julia code such as exports and macros can be defined.

It is also possible to replace the `@wrapmodule` call with a call to `@readmodule` and then separately call `@wraptypes` and `@wrapfunctions`.
This allows using the types before the functions get called, which is useful for overloading the `argument_overloads` with types defined on the C++ side.

## STL support

Version 0.9 introduces basic support for the C++ standard library, with mappings for `std::vector` (`StdVector`) and `std::string` (`StdString`).
To add support for e.g. vectors of your own type `World`, either just add methods that use an `std::vector<World>` as an argument, or manually wrap them using `jlcxx::stl::apply_stl<World>(mod);`.

If the type `World` contains methods that take or return `std::` collections of type `World` or `World*`, however, you must first complete the type, so that CxxWrap can generate the type and the template specializations for the `std::` collections.
In this case, you can add those methods to your type like this:

```
jlcxx::stl::apply_stl<World*>(mod);
mod.method("getSecondaryWorldVector", [](const World* p)->const std::vector<World*>& {
    return p->getSecondaries();
});
```

Linking wrappers using STL support requires adding `JlCxx::cxxwrap_julia_stl` to the `target_link_libraries` command in `CMakeLists.txt`.

## Breaking changes for CxxWrap 0.7

* `JULIA_CPP_MODULE_BEGIN` and `JULIA_CPP_MODULE_END` no longer exists, define a function with return type `JLCXX_MODULE` in the global namespace instead.
  By default, the Julia side expects this function to be named `define_julia_module`, but another name can be chosen and passed as a second argument to `@wrapmodule`.

* `wrap_modules` is removed, replace `wrap_modules(lib_file_path)` with:
  ```julia
  module Foo
    using CxxWrap
    @wrapmodule(lib_file_path)
  end
  ```

* `export_symbols` is removed, since all C++ modules are now wrapped in a corresponding module declared on the Julia side, so the regular Julia export statement can be used.

* `safe_cfunction` is now a macro, just like `cfunction` became a macro in Julia.

* Precompilation: add this function after the `@wrapmodule` macro:
  ```julia
  function __init__()
    @initcxx
  end
  ```

## Breaking changes in v0.9

* No automatic conversion between Julia `String` and `std::string`, but `StdString` (which maps `std::string`) implements the Julia `AbstractString`interface.
* No automatic dereference of const ref
* `ArrayRef` no longer supports boxed values
* Custom smart pointer: use `jlcxx::add_smart_pointer<MySmartPointer>(module, "MySmartPointer")`
* `IsMirroredType` instead of `IsImmutable` and `IsBits`, added using `map_type`.
  By default, `IsMirroredType` is true for trivial standard layout types, so if you want to wrap these normally
  (i.e. you get an unexpected error `Mirrored types (marked with IsMirroredType) can't be added using add_type, map them directly to a struct instead and use map_type`) then you have to explicitly disable the mirroring for that type:
   ```c++
   template<> struct IsMirroredType<Foo> : std::false_type { };
   ```
* `box` C++ function takes an explicit template argument
* Introduction of specific integer types, such as `CxxBool`, that map to the C++ equivalent (should be transparent except for template parameters)
* Defining `SuperType` on the C++ side is now necessary for any kind of casting to base class, because the previous implementation was wrong in the case of multiple inheritance.
* Use `Ref(CxxPtr(x))` for pointer or reference to pointer
* Use `CxxPtr{MyData}(C_NULL)` instead of `nullptr(MyData)`
* Defining a C++ supertype in C++ must now be done using the `jlcxx::julia_base_type<T>()` function instead of `jlcxx::julia_type<T>()`

## Breaking changes in v0.10
* Requires Julia 1.3 for the use of JLL packages
* Reorganized integer types so the fixed-size types always map to built-in Julia types

## References
* [JuliaCon 2020 Talk: Julia and C++: a technical overview of CxxWrap.jl](https://www.youtube.com/watch?v=u7IaXwKSUU0)
* [JuliaCon 2020 Workshop: Wrapping a C++ library using CxxWrap.jl](https://www.youtube.com/watch?v=VoXmXtqLhdo)

redpajama_set_name: RedPajamaGithub


text:
Say goodbye to the spreadsheet
Chris Nichols, Microsoft Dynamics Consultant at Columbus UK, explains the features SMBs should look for in an end-to-end business management solution. And guess what, these are the features big businesses use all the time.
Many smaller businesses still track financial and operational data through a combination of complicated spreadsheets and basic accounting software. But as digital transformation gathers pace and cheaper and easy-to-deploy cloud solutions hit the market, having a dedicated end-to-end solution for business management not only becomes more feasible but necessary in order to stay competitive.
Why would SMBs look to change their current business management systems? At Columbus, we often find it's due to a combination of multiple pain points, rather than one specific issue – but leading the way is always business growth.
Many SMBs simply outgrow existing systems that are either too inflexible to scale in line with business growth or incapable of supporting an increasing number of users. A solution that can onboard additional users without incurring major expense and scale to handle larger volumes of data becomes a 'must-have'.
Levelling the field
As SMBs grow, they typically seize the opportunity to introduce additional functionality for management and monitoring. By eliminating siloed information in an end-to-end solution, business leaders can achieve a more holistic view of operations and connect employees better to make day-to-day work more collaborative. Employee efficiency gains can be boosted further by reducing or automating manual, repetitive tasks such as completing purchase orders.
Many software vendors are beginning to tailor their ERP solutions to fit the needs of SMBs specifically. One recent example is Microsoft Dynamics 365 Business Central, which introduces more advanced functionality focused on unlocking greater insights and minimising deployment costs for smaller businesses.
New business management
solutions have progressed far beyond simply offering a 'single pane of glass' to view top-level organisational data. Integrated Business Intelligence (BI) and advanced data analytics deliver actionable insights to business leaders and allow them to make informed decisions or respond quickly to changes in the business environment. By directly embedding BI tools, such as Power BI, into CRM, sales and marketing systems, these decisions can be made in real-time.
This is where the playing field is truly levelled for SMBs, by enabling them to make data-driven business decisions on a par with larger competitors, with no more time consuming spreadsheet analysis to identify patterns and trends. In the case of Power BI, users can harness pre-set Microsoft reports that provide visualisations of datasets and specific insights or they can create their own.
Nor are emerging technologies, such as the Internet of Things (IoT), any longer restricted to the largest of enterprises. The average cost of IoT sensors has fallen year-on-year for over a decade and is projected to fall further, bringing new possibilities to SMEs.
For example, by fitting IoT devices to machinery on the factory floor and feeding data streams into a BI suite, such as Cortana Intelligence, a typical SME manufacturer can identify areas of inefficiency, predict when machinery is likely to break down and schedule maintenance accordingly. This ensures that they carry out maintenance only when necessary, avoiding the cost of scheduled maintenance and the downtime caused by machinery breakdown.
Easing growing pains
Another factor that cannot be ignored is scalability. As an SME grows, supporting infrastructure must scale accordingly or risk a breakdown in operations.
Subscription-based models are a popular deployment choice. They eliminate the need continually to purchase, transfer or renew licenses and, by enabling new users to be added or removed at the 'click of a button', reduce the risk of overspending on licenses.
Cloud-hosted business management solutions take the need to deploy, manage and adapt infrastructure away from SMBs, allowing them to focus on day-today operations.
Cloud-based delivery also streamlines deployment, minimising the risk of disruption to ongoing business operations. Business Central, for example, can be deployed in as little as 10 days, including all necessary training.
Easy implementation doesn't just apply to Business Central's core solution suite. Users can also add extensions or purchase apps offering extra functionality. If an SMB requires sales orders to be presented in a specific format, say, or wants to introduce a cross-sell functionality, the required extensions or apps can be installed in minutes.
No-risk approach
For SMEs on limited budgets but with the desire to embrace digital transformation, a subscription-based business management solution delivered from the cloud offers a no risk approach to transitioning away from spreadsheets and disjointed financial systems.
Actively connecting people, processes and systems allows key decision-makers to boost productivity and take a hands-on approach to business management informed by granular business insights.
To keep pace with digital transformation, businesses should avoid multiple systems that each address a specific business area and, instead, work with an implementation partner to tailor an end-to-end solution to their specific business needs, processes and workflows.
Chris Nichols
Cortana Intelligence
Microsoft Dynamics Consultant at Columbus UK

redpajama_set_name: RedPajamaCommonCrawl


Polymer Testing Laboratory | Birch Plastics Inc.
Our in-house polymer testing facility is the heart of our company. Our certified lab gives Birch the ability to conduct quality control testing on everything we do. We also offer these services as part of our toll R&D and Short Run Compounding and our Commercial Compounding options.
Birch works with resin distributors, R&D teams, and end users to perform a variety of tests to insure material accuracy. Our most popular service is melt index testing. Our customers really see an advantage to having third party testing on every compartment of their railcars to assure accuracy.
At Birch Plastics we offer third party polymer testing as well as developmental testing services. Focusing on lifecycle stability, we can help you determine just how many times you can reuse your plastic resin before reaching the point of total loss of physical properties. Our process is to extrude your polymer into pellets and repeat this heat history process up to a hundred times. While processing your plastic resin we pull samples of each run. We can either send the sample back for you to test or we offer our laboratory testing equipment as part of the service. Many of our clients are plastic additive manufacturers, product development companies, or end user processors. We offer them the ability to do ladder studies on the performance of their products like antioxidants and thermal stabilizers by recycling their product repeatedly until failure to find the limits of what is possible.
When developing a product made from recycled plastic, physical integrity is key. Here at Birch, we can help you determine how much recycled content you can use without compromising the physical properties of your part. One of the ways we can help is to pelletize various percentages of recycled material into virgin resin so you can run trials in your mold, or we can test the results here in our lab to help determine what will work best. We also have the ability to enhance the physical properties of recycled resin to increase strength, durability, help with odor control, and protection from environmental stress created from UV damage.


• Captions appear automatically on all calls - incoming and outgoing. No need for callers to dial through the Captioning Service.
• Wi-Fi compatible to position anywhere within your wireless network range Captions can be turned on or off at any time in a call.
• Built-in Answering Machine takes voice messages with captions Large, easy-to-read captions window with adjustable font sizes and colors.
• Display screen tilts for comfortable reading or lies flat to mount the phone on a wall.
• Adjustable volume control (up to 40dB gain) for captioned calls.
• Volume button is easy to see and adjust during a call.
• One-touch access to CapTel Customer Service (speed dial button automatically connects you to CapTel Help Line).
• Easy-to-follow menu system with Yes/No questions.
• Phone Book allows you to easily store and dial more than 95 names/phone numbers.
• Speed dial keys for one-touch dialing of frequently called numbers.
• Caller-ID capable - shows you who is calling directly on display screen.
• Captions available on calls within the United States only.


text:
Q: Hive error TSocket read 0 bytes and TTransportException I am busy upgrading our AWS EMR cluster to a newer version and I have started running into issues.
The errors are only occur on the newer version (Hive 3.1.3).
All my queries run fine on the older version (Hive 2.8.5)
The error I get when trying to insert into or insert overwrite is:
Could not connect to any of [('IP', port)] (code THRIFTTRANSPORT): TTransportException("Could not connect to any of [('IP', port)]",)

    AND

TSocket read 0 bytes

I use Hive to do some ETL.
We host an EMR cluster that uses Hive, Hue, Tez, Pig.
The tables are build as external tables on parquet files stored in S3.
Some of these tables are partitioned.
On the current version, these are the sets I use before running the queries:
SET hive.vectorized.execution.enabled = true;
SET hive.vectorized.execution.reduce.enabled = true;
SET hive.vectorized.execution.reduce.groupby.enabled = true;
SET hive.cbo.enable=true;
SET hive.compute.query.using.stats=true;
SET hive.stats.fetch.column.stats=true;
SET hive.stats.fetch.partition.stats=true;
SET hive.execution.engine=mr;
SET hive.exec.parallel=true;
SET hive.exec.dynamic.partition.mode=nonstrict;
SET hive.exec.max.dynamic.partitions=10000;
SET hive.exec.max.dynamic.partitions.pernode=10000;
SET hive.exec.max.created.files=500000;
SET hive.metastore.sasl.enabled = true; --Newly add this but still getting these errors

On the later version this set no longer works:
SET hive.stats.fetch.partition.stats=true;

Current Version:
Release label:emr-5.27.0
Hadoop distribution:Amazon 2.8.5
Applications:Hive 2.3.5, Hue 4.4.0, Tez 0.9.2, Pig 0.17.0, Hadoop 2.8.5

Wanted version:
Release label:emr-6.7.0
Hadoop distribution:Amazon 3.2.1
Applications:Hive 3.1.3, Hue 4.10.0, Tez 0.9.2, Pig 0.17.0, Hadoop 3.2.1

Are there SET's that I am missing or is there something else I am missing?
Any advise would be greatly appreciated.

redpajama_set_name: RedPajamaStackExchange


text:
Q: Alamofire sending object as parameter I'm having hard time doing something simple. The data I want to send is the following:
  {
    "nickname":"Rado",
    "social": {
      "data: {
        "accesstoken":"xx",
        "applicationId":"xx",
        "userId":"xx"
      },
      "type":"whatever"
    }
  }

Currently I'm doing that:
           let params = [
                "nickname": userName,
                "social": [
                    "type": "whatever",
                    "data": [
                        "userId": accessToken.userID,
                        "accesstoken": accessToken.tokenString,
                        "applicationId": accessToken.appID
                    ]
                ]
            ]

 Alamofire.request(.POST, "url/users", parameters: params, headers: nil)
                .responseJSON { response in

}
As a response I get this:
{
 "nickname":"Rado",
 "social[data][userId]":"xx",
 "social[data][applicationId]":"xx",
 "social[data][accesstoken]":"xx",
 "social[type]":"something"
}

Any advice will be appreciated!

A: The solution turned out to be really simple. I was missing encoding: .JSON
    Alamofire.request(.POST, "url/users", parameters: params, headers: nil, encoding: .JSON)
        .responseJSON { response in

    }


text:
Can freshmen be RA?
Question: Can freshmen be RA?
What year can you be an RA?
What is a freshman dorm RA?
Can graduate students be RA?
What is an RA at a college dorm?
Can an RA enter your room?
Do RA get their own rooms?
How do I become a USC RA?
What is RA position?
Is it worth being an RA?
Do you get paid to be a RA?
Can an RA Check your fridge?
Does being an RA affect financial aid USC?
How can I be a good RA?
Can an RA date a resident?
Are RAs allowed to search your room?
How do you hide alcohol from RA?
RAs, or Resident Assistants, are the people who live on the floor with the residents and act as kind of the parent of the floor. Now, you cant RA as a freshman student.
To become an RA, you must first earn at least 40 undergraduate credits at your chosen university or college. Many RAs start off as first year undergraduate students and then apply for the position for the second year of their degree.
A resident adviser—or RA—is an upperclassman who is available to college students living in dorms and resident halls. Dorm residents may be more comfortable talking to an RA than an older adult in a sterile on-campus housing office, making this peer-to-peer guidance can be valuable for incoming freshmen.
Graduate students with residence life experience at another institution need to have been enrolled at UVA for at least one year to be eligible to apply for an RA position in upperclass areas. Graduate students may also serve fellow residents in on-Grounds graduate housing communities as a Community Assistant.
Resident Assistants (RAs) are undergraduate or graduate student staff members who live in the residence halls. RAs receive free housing and a meal plan in exchange for their work in the halls. The decision to become an RA is not one that should be made lightly. It is a demanding, challenging, and rewarding position.
An RA is allowed to enter the room if there are signs of abusive drinking behavior – someone screaming shots or hearing a ping pong ball. However, even in that scenario we are trained to knock first, and only if no one will let you in, you must announce that you are an RA and are going to come in with your key."
Some colleges give RAs their own private dorm room. This perk is a huge benefit, especially for students who want more privacy but cant afford a single room. Beyond the increase in quality of life, living without a roommate can allow you to focus more deeply on your studies and get a better nights sleep.
Qualifications to be an RA:have full-time student status.have been at USC for at least one year or one semester (for Spring Admits)have at least a 2.5 cumulative GPA and maintain a 2.5 semester GPA (3.0 for graduate students)not have classes Wednesday evenings between 7:30-9:30 pm.More items
A resident assistant (also variously known as a house fellow, resident advisor, community assistant, resident mentor, residence don, peer advisor, community advisor, collegiate fellow, or senior resident), commonly shortened to RA, is a trained peer leader who coordinates activities in residence halls in colleges,
If you dont think youll have enough time to be an RA and handle all of your school work, it may not be worth the effort. If youre on the fence about whether or not youll be able to handle the time commitment with your workload it could be worth talking to a current RA who is in your major or program of study.
A: All RAs are paid $2310 for the academic year. If RAs work any additional desk hours over the required 5 a week, the RA will be paid minimum wage for those hours, which is $7.25.
They can and do observe anything in open drawers and closets and in plain view. There are times when an RA can enter and even search unannounced. The only time a container is searched without explicit consent is during announced safety inspections and at every closing of the semester or year.
Resident Assistants have a lower cost of attendance than most students at USC. As a result, the financial aid summary may indicate a reduction in aid.
What Makes a Great Resident Assistant?Recognize that experience does matter. Live by a good set of ethical standards. Posses a good attitude. Proactively request feedback so they can improve. Be able to challenge peer attitudes and behaviors when needed. Demonstrate the ability to facilitate individual conversation.11 Aug 2014
The policies at each university vary, but I got the 411 on the way it works at Syracuse. At their simplest, the rules state that an RA cannot date a student on his or her floor OR in the same building. The only way to get around this is by going to the resident director, the person above the RAs, and arguing your case.
Lets say youve got some alcohol. You just know your RA is going to take that away from you the first chance they get. But heres a way around that: put your tipple in a mouthwash bottle, and theyll just think youre all about oral hygiene. For extra points, add a drop or two of food coloring.


Work shirts are designed to protect the upper part of the body or torso along with hands and arms against normal workplace hazards. Work shirts are also worn as a normal piece of clothing and come in a large variety as there are waterproof shirts, office shirts, flame-retardant shirts, hooded shirts, sweatshirts, t-shirts, polo shirts available in the market. Due to their use across a wide spectrum of industries, work shirts may differ significantly from each other and can be made up of various fabrics such as cotton, wool, silk, nylon, polyester or polycotton etc. Work shirts are one of the most widely used pieces of workwear and are used by almost every worker in one form or other. "
Corporate office shirts have become the norm in most types of offices and can be seen in any office or workplace. Corporate office shirts are mainly used for formal settings and come in hundreds of shades and colours. Although in the past most corporate shirts were made up of cotton, wool or silk, nowadays synthetic fibres such as polyester are also used.
Flame retardant shirts like other flame retardant clothing are made up of flame retardant materials which inhibit and supress the spread of fire. Their basic aim is to protect the wearer by allowing him some time to escape as no fire resistant or flame retardant materials is 100% fireproof and most materials will start to burn at sufficiently high temperatures.
Hooded sweatshirts can be seen in all workplaces during winter as these allow an easy way to protest the torso along with head and neck from cold weather. Nowadays, most hooded sweatshirts are made up of polycotton and polyester.
Sweatshirts are the preferred choice of millions of workers are most extensively used in outdoor work environments. Sweatshirts are mostly made up of cotton, wool, polyester or a combination of natural and synthetic fabrics. In recent years use of polycotton t-shirts with higher ratio of cotton has increased significantly.
T-shirts are arguably the most common form of shirts after normal collared shirts with buttons. T-shirts are used in workplaces, offices, schools, sports and have become the most easily spotted item of clothing almost anywhere on this planet. Due to their lightweight, cheap prices, easy wash ability these are preferred over other shirts.
Work shirts refer to any type of shirt which has been designed to be primarily used in an office or workplace. Work shirts are normally made up of cotton, polycotton, polyester, wool or silk and are available in hundreds of colours and designs.
Work polo shirts are a slightly modified version of normal polo shirts as these can have some additional features and are in most of the cases used as uniform across various large businesses and organizations. Polo shirts are made up of knitted fabric and nowadays most polo shirts are made using polycotton or cotton.
Work t-shirts are t-shirts designed to be used at workplaces. As expected, these often have additional features not commonly found in normal t-shirts such fire retardant properties, anti-bacterial, anti-static which protects workers from health hazards at workplaces. Various materials such as Cotton, Cotton Rich, 100% Polyester, Polycotton, 100% Polypropylene, Polyamide Rich, Elastane, Polyester Rich are used for making work t-shirts.


but each had different reasons.
and we buy services from other counties that have overbuilt. That creates its own problems with safety and transportation.
and provide public parks and trails.
but thought it would come at a cost to other services in the county.
but does it have to be subsidized by the taxpayer?" Cardella countered.


We are movers, who care about the changing of your place of residence. We are professionals, who provide the best services in Newport Beach. We are the team, which care about your mood and your health. That is why people choose us and that is why we choose t to be responsible and the best. We can do all duties instead of you, you don`t have reason to worry, you should just enjoy the free time and perfect work.
Preparing. Our movers come to the company, explain t all process of moving, make a plan with the manager and make a checklist of all furniture.
Packing. We provide all needed packing materials (from different types of boxes to wrapping papers), pack all the office furniture, and even put them into the vans.
Transportation. To move your workplace to Newport Beach we hired the best drivers and bought the best vehicle, which delivers all the office furniture on time and without troubles.
Unpacking. We understand that you don't have much desire and time to unpack all and put in on its place in the new office. But we can do it instead of workers of your company.
Insurance. Of course, we provide insurance for our business clients, which will help them to be calm and not worry about your office.
Don`t worry if you have a small company. We have a special service for such companies because we understand that everyone can need help. We have discounts for little companies, furthermore, if you have little company, you have not many items of furniture, that is why your moving won`t be expensive. So, if you still be undecided – there is nothing to think about.
You should remember, that the best friend for your office moving is a business moving company in Newport Beach, which is always ready to help you, pack and transport your furniture and make you a good mood. So, fill in the form and wait for the best business moving to Newport Beach.


I used some fabulous Sheila's Sock from Fyberspates, that I received in a sock club back in 2011 (how things linger, waiting for that perfect project!). Sadly, Jeni's not doing hand-dyed yarn these days, so if you want something similar, you'll need to use her Vivacious 4ply, which knits up quite similarly.
The stitch pattern Rachel has used makes these socks satisfying to knit - the ribs line up so that you know you're in the right place. The bobbly bits make it one of those just one more repeat projects, so when I was actually knitting on them, they seemed to fly off my needles at quite a pace.


1760 stainless steel checker plate manufacturers & wholesalers provide best stainless steel checker plate from China.
Stainless steel checker plate, standard weight table, flooring application. Stainless steel checker plate have the features of strong corrosion resistance.
Wuxi Kerui Dite Stainless SteelImport& Export Co., Ltd. is located in China's largest stainless steel processing center ... Product-stainless steel checkered plate.
stainless steel checker plate on sale, 1735 stainless steel checker plate manufacturers & stainless steel checker plate suppliers from China.


text:
Etikettarkiv: informal butchers
Photos by Mark Lewis of informal butchers in Johannesburg
S'kop (Fourthwall Books) by Tanya Zack and Mark Lewis. S'kop is short for isiKop – "the head" – in a hybrid Zulu/Afrikaans slang.
South Africa has undergone dramatic change since apartheid was abolished 1990 and free elections were held 1994. The South African society is still changing, on many different levels, and one place in particular has changed rapidly the last decades: Johannesburg.
The big insurance and banking companies began to invest heavily in the suburbs, particularly the northern suburbs, in the 80s. This triggered a flight of white and affluent people from the inner city and more and more companies moved their headquarters as well. The inner city became less attractive, parts of it was totally neglected, but Johannesburg is a typical "arrival city", it's not only attracting South Africans in search for opportunity, it attracts Africans seeking opportunity from the entire region. From Zimbabwe, Angola, Mozambique, Nigeria, Somalia, Ethiopia among other countries.
In only ten years, between 2001 and 2011, the province of Guateng, of which Johannesburg is capital, grew by 30%. During the apartheid years the inner city of Johannesburg was virtually all white. Today, according to some estimates, less than 50% of the population is South African and of them only a very small minority is white.
The photographer Mark Lewis has worked a lot in Johannesburg during the last decades, and we are very grateful that we may publish a few of his amazing images of informal butchers in Johannesburg, most of them Zimbabwean immigrants. We also asked Mark a couple of questions.
Could you please tell us a little bit about yourself? How did you become a photographer, how did you develop your style and interest in telling stories?
– I kind of slipped into photography. I got a job painting the interior of a photographer's studio and ended up staying on as his assistant. I then did advertising photography and moved to London in the 80s and started doing fashion photography for magazines like Blitz and The Face. I viewed my work with those magazines, in particular Blitz Magazine, as more social documentary than fashion as it really reflected the times and in that way the fashion of the day, post punk and the beginning of Thatcherite England.
– I returned to South Africa in 1994 and started doing work with an Africa Correspondent for various German publications so that work took me into the continent and that opened my eyes to a new beginning in photography and one that I felt more comfortable with. It was when I returned to live in Joburg after a very long absence that I met up with Tanya Zack and we both discovered our mutual desire to seek and tell stories of this ever changing city, and so began the Wake Up This Is Joburg series. Tanya's knowledge of the city through her work as an Urban Planner enabled me to look at the city in a new way. It has also increased my interest in urbanisation and the changes that are taking place in the peri-urban landscape in Joburg, South Africa and in the rest of the continent.
S'kop is the first book in the Wake Up-series. Could you please tell us a little bit about the series and why you began to focus on the Kazerne, that ceased to function as a parking garage in the late 1980s and then became a taxi rank?
– Wake Up This Is Joburg is a series of 10 booklets, it tells the stories of 10 ordinary, interesting, odd or outrageous denizens of the city of Johannesburg. It was first conceived as one book by Tanya and myself, S'kop, but Fourthwall Books suggested we do it as 10 stories which we both liked. Tanyas and my initial thoughts were about looking at movement in and through the inner city; how urban space gets continually altered and abandoned and hijacked and also how people navigate through these altered, abandoned and hijacked spaces. So seeing cow heads pushed through the city centre in Woolworths shopping trolleys fitted exactly into what I was hoping to find. The heads are collected every day from the inner city butcheries and pushed to various abandoned or left over spaces around the city where they are chopped and cooked.
– On entering the abandoned space which had been a parking garage and then a taxi rank and was now occupied by informal butchers wielding axes and knives and smoke billowing from fires cooking huge pots of porridge and meat, and skulls and skins piled upon blackened concrete floors, it was quite an extraordinary site, the light was wonderful and we were soon welcomed into their space and allowed to witness this process. But then the extraordinary becomes the ordinary and then you can see it for what it is, which is a startling story of entrepreneurship and survival in the city.
All photos © Mark Lewis
The Kazerne, also known as Second Kazerne Parking Garage, 66 Harrison Street, was built 1963 and demolished 2013.
Under Bokomslag bilder och foto
Taggat som foton, Fourthwall Books, informal butchers, Joburg, Johannesburg, Mark Lewis, photos, South Africa, Tanya Zack


text:
You are here: Home Eastern Europe Lithuania KAUNAS: Kaunas County, Kaunas district
KAUNAS: Kaunas County, Kaunas district
Alternate�names: Kaunas [Lith], Kovno, ????? [Rus], Kovne, ????? [Yid], Kovna [Heb], Kowno [Pol], Kauen [Ger]. 54�54' N, 23�54' E. Jewish population: 25,448 (in 1897), 40,000 (1914).
Encyclopedia of Jewish Life (2001), pp. 604-609: "Kaunas"
Pinkas HaKehilot, Lithuania (1996), p. 512: "Kaunas"
Shtetl Finder (1989), p. 41: "Kovno".
Surviving the Holocaust: The Kovno Ghetto diary (, 1990)
Hidden History of the Kovno Ghetto (Washington DC, 1997)
(Moscow, 1948)
Kovno Ha'Yehudit Be'khurbana (Jerusalem, 1959)
Haichel Sh'sheka; HaHinuch HaEvrei B'Kovna - Mosdot v'Ishim (Tel Aviv, 1962)
Pinkasim fun Balbirishuk, Zidik, Yurbarik, Kovne, Vilne, Shnadau, Shkod, Mestislav Hadash, Pruzhani (, )
JOWBR: Viliampole Chevra Kadisha, 1941-1943
ShtetLink. [October 2001] Litvak SIG article. [November 2002]
Jewish history. [September 2010]
VIDEO: Jurbarkas-Kaunas-Sauliai (Shavel)-Pokrojis-Birzai (226KB)� - Online video of the cemeteries and synagogues of Jurbarkas, Kaunas and Pokrojis. Watch and listen to interviews with leaders of� the Jewish communities in� Kovno and Birzh. See views of� the streets and� meetings with other local Jewish people.[March 2009]
VIDEO: Kaunas 9th forth-Saulenai-Sauliai-Joniskis-Taurage-Vainutas-Silute-Telsiai-Mazheiki-Leckava-Bauska (195KB) - Visit the archives in Kaunas, then terrible Nazi prison 9th fort. See the cemetery in Shavlyan, old synagogues in Shavel, Joniskis, Taurage. Jewish cemetery and famous Yeshiva in Telsiai, listen the interview with the leader of community in Yiddish. Leckava- the cemetery and the town. Bauska- views of the old town and the exhibition "Jews in Bauska" in local Museum. [March 2009]
BOOK: "Hidden History of the Kovno Ghetto, by Walter Reich" is an incredible book in its dimension of historical fact and documentation. The book begins in the summer 1941 - soon after German troops invaded Soviet territory and ends with the mass-murder of Jews and total incineration of the Kovno Ghetto.
VIDEO: Film of Kaunas cemetery by Tomek Wisniewski: YouTube
PHOTO GALLERIES:� http://elirab.me/2014/05/22/kaunas-kovno-lithuania/
http://elirab.me/2014/05/25/from-kaunas-to-klaipeda/
"Heytab Kadisha" burial society of Viliampole [Viliampoliai, Slabodke, Slobodka]: Burial list is held in the archives of the Beit Lochamai HaGetaot, the Ghetto Fighters Museum in Israel. The list is of those who died between 18 August 1941 and 31 December 1943. Yitzhak bar Moshe Devortsky produced the document. Members of the JewishGen and LitvakSIG and Dorothy Kohanski's senior group translated the names. Dr. Josef Ash, Rabbi Edward Cohen, Marc Dver, Prof. G.L. Esterson, Rodney Falk, Zvi Griliches, Ellen A. Jacobsm Harold Friedman, Yetta Gotsyn, Alex Malkin, Martha Lev-Zion, Avi Lishower, Jeffrey Maynard, Kevin Ossey, Harold Rhode, Robert Weiss, Jim Yarin, with co-ordinator This e-mail address is being protected from spambots. You need JavaScript enabled to view it . Kovno Cemetery lists of Jewish dead buried in Kovno cemetery for the years 1941-1943. Manuscript. Yiddish. 50 pages. Sent by Mr. Zvi Asherat, Israel. Mar. 22, 1982. Xerox copy. Vital Statistics file. American Jewish Archive, 3101 Clifton Ave. Cincinnati, Ohio 45220-2488; phone (513) 221-1875.
Three Jewish cemeteries can be visited in and around the city center:. The Old Jewish Cemetery to the north of ?�uolynas is now a place for local drunk youths with graffiti filled walls and a selection of broken gravestones. The Old Jewish Cemetery in Vilijampol? was destroyed with most of its gravestones some time after WWII but if you walk to the far northern end of the field you'll find many old gravestones, some hundreds of years old, on the hill surrounded by a wood.
The Jewish community numbers about 600. Greenhill Cemetery is located in a residential area of Kaunas. This inactive cemetery is sadly neglected, but with outside help can be restored. Aleksot Jewish cemetery is an active use today, very well maintained and in excellent condition.There is a central cemetery office in Kaunas where the records for all cemeteries in Kaunas are kept. For the Jewish cemeteries, they only have records of Jews were buried since 1965. All other Jewish cemetery records are either missing or destroyed. The cemetery office is at KAPINIU PRIEZIUROS KONTORA, DONELAICIO G-VE 70, KAUNAS, LITHUANIA. Source: This e-mail address is being protected from spambots. You need JavaScript enabled to view it [August 2007]
Panemunes Cemetery: (Auk�tosios Panemun?s). 178 Viadoto Gotve Str. t. Established 1710, the site currently is protected as a Jewish cemetery. Located between Vaidotas Street and the Nemunas River. An entrance sign in Lithuanian reads "SENOSIOS �YDU KAPIN0S TEBUNIE �VENTAS MIRUSIUJU ATMINIMAS" with a Star of David. GThe gravestones are buried so deep into the ground that the inscriptions cannot be read. Only 3 gravestones are visible. The cemetery is owned by the local municipality. information. [September 2010]
"The original Kovno Jewish cemetery was inactivated and pretty much destroyed in the early 1970s, presumably to make way for a highway or some such project that was apparently never built. Friends of mine who visited the site last summer said it was in horrible disarray, not kept up at all for years. Families still in Lithuania or the Soviet Union at the time were given the option of moving their relatives' graves to what is now the active Jewish cemetery, south of the Niemen (Nemunas) River, near Panemune, I think. I had an uncle in the Soviet Union at the time, so I knew about this ... This cemetery is relatively well kept, and still in use. Unfortunately, there is no signage at the entrance nor are there signs directing drivers to the cemetery's location. People in the area, however, were kind and helpful when we asked for directions." Source: JewishGen Digest, 12 Sept 2004. [September 2004]
Vilijampoles (Kauno Vilijampol?s) Cemetery: information. [September 2010]
Vilijampoles Cemetery (Kaln? Street): Information. [September 2010]
Aleksotas Cemetery: Kaunas' only remaining active Jewish Cemetery in Aleksotas can be accessed through a gate at the back of the Naleksta factory on H ir O Minkovski?.
CEMETERY: This very large, still-active cemetery is very well maintained and contains several thousand stones. Some are in very good condition, mostly newer stones. Some stones have been moved from other cemeteries. Kaunas (Kovno) cemetery is huge. Jewish community has only legally been able to maintain it since 1991. Between WWII and 1991 for construction, locals carried off many hundreds of stones. Many brick tombs were dismantled. Thousands of stones remain in an area that covers perhaps 20-30 acres. As of 1993, the city was negotiating with the Jewish community. The city wanted to demolish a portion of the cemetery, alleging the site was overgrown and beyond the capacity of the Jewish community to maintain. The community supposedly does possess cemetery records, although I did not see them. The cemetery is overwhelming. Overrun with vegetation and in a state of dilapidation, thousands of fine stones still standing. Source: This e-mail address is being protected from spambots. You need JavaScript enabled to view it [date?]
The Jewish cemetery in Kaunas, the second largest city in Lithuania, is accessed through an area that formerly housed Soviet army units and now serves the same purpose for the Lithuanian army. The cemetery is adjacent to this area of army barracks, across a single railroad track, and physically separated by a fence. The gravestones and markers are generally in good condition and readable, with names in both Yiddish and Lithuanian. The newer stones often have photos of the deceased or the likeness carved in the stone. There has been some minor vandalism, but relatively little defacement or damage to the markers. Only one stone was observed that had sustained significant damage at the hands of vandals. This stone, which has been rather crudely repaired, belonged to one of my relatives. At one end of the cemetery is a memorial to those who died in the Kaunas (Kovno) Ghetto during WW II. Nearby is the grave of a prominent rabbi, nearly a century old, and that of his son. The small Jewish population of Kaunas, numbering now about 300, still remembers this historic religious figure as evidenced by the stones placed on the grave and a still-burning Yahrzeit candle during my visit. Source: This e-mail address is being protected from spambots. You need JavaScript enabled to view it [date?]
UPDATE: No need to go through army barracks or over train tracks. There is a large open gate on Radvilenu St. The ohel on the grave of Rabbi Yitchak Elchonon Spector and his son has been demolished by vandalism. I�could not find traces of the gravestone either. I gather quite a lot of vandalism has gone on in the past couple of years. This e-mail address is being protected from spambots. You need JavaScript enabled to view it , Jerusalem, Israel. [August 2003] UPDATE: "Mr. Fuss's information is inaccurate. Access to the cemetery: you must still go in through the barracks/industrial site and cross a track. Rabbi Yitchack Elchanan Spector and Rabbi Tvi Rabinovitz are both in perfect condition in an ohel at the end of the cemetery." This e-mail address is being protected from spambots. You need JavaScript enabled to view it : [May 2005]
cemetery photos. photos. [September 2010]
HOLOCAUST and MASS GRAVES: Story of Kovno Ghetto with photos. Links to multiple stories about the ghetto. Fort #9 is one of many old forts surrounding Kaunas. The Nazis converted them into killing grounds. Sgns and stones tell how many thousands are buried in each mass grave. The Lithuanian government is looking after all these places and taking good care of the sites. At Fort #9 a museum and a huge memorial commemorating the dead. [March 2009]
MACEVA is a non-profit Jewish led organization in Lithuania dedicated to restoring Jewish cemeteries there. MACEVA, has achieved a monumental accomplishment. With urging from MACEVA, the city of Kaunas has agreed to help in the restoration of the old Kaunas Zaliakalnis Jewish cemetery - 80,000 sq. meters of desecrated grave stones. Litvak SIG, the Kaunas Jewish community, and Maceva will monitor the work. I have visited that cemetery and most of the gravestones are made of granite instead of marble or sandstone. Consequently, many of the gravestones are very legible. The problem is, many stones have toppled over, or are broken into several pieces. Vegetation growth is also a major problem. After restoration, photos will be taken of the gravestones and will be made available. The data that results from MACEVA's work will appear in the LitvakSIG All Lithuania Database. The major need now is for contributions so the restoration and photos can be accomplished. Go to www.litvaksig.org/contribute and make your contribution. Any amount will be appreciated. Scroll down to SPECIAL PROJECT. Leave the PROJECT blank. In the NOTE Block, key in MACEVA. Feel free to use your credit card as the site is secure. This is not to be confused with the new Jewish cemetery in Kaunas. which is in excellent condition and very well maintained. For information about the graves in that cemetery, please contact the Kaunas Cemetery Office, where they keep cemetery records from all the cemeteries in Kaunas. For the Jewish records they only have records for the Jews who died in Kaunas in 1965 and later. All other Jewish cemetery records are either missing or destroyed. The Jewish records they have, are recorded in 2 books, one line per person Cemetery Office is: KAPINIU PRIEZIUROS KONTORA DONELAICIO G-VE 70 KAUNAS, Lithuania Source: Howard Margol, This e-mail address is being protected from spambots. You need JavaScript enabled to view it via JewishGen Digests [June 2012]
Photos courtesy This e-mail address is being protected from spambots. You need JavaScript enabled to view it
[UPDATE]: Lithuania: Report on 2015 activities of MACEVA Jewish cemetery organization [June 2016]
[UPDATE] Cemetery work in Kaunas [August 2017]
Last Updated on Thursday, 10 August 2017 22:51


text:
Interview with Mike Scalzi of Slough Feg
"If you wanna sell albums, start imitating!!!"
Interview by Jason Guest
Hi Mike. Thank you very much for taking time out for this interview and congratulations on Digital Resistance (reviewed here). How long were you working on the album?
It took about nine months, but we didn't work straight through, we had to take long breaks because of work, etc.
The album title is far from subtle and establishes a theme of resistance against the digital age. What's your view on technology, its effect on the world and the individual, and the relationship between them?
I don't know what it's doing to me, or anyone else for that matter. I'm too much in the middle of it; in fact any answer I could give would be one that is at least partially created by technology. Technology is in us, it is us. It's too late to objectively analyze it. Having said that, I find my dependence on it annoying, although I could stop using it, then I would be extremely isolated. So I choose to use it and complain. But there's no stopping it at this point, we're in it for good. My internet service went down yesterday. I felt incomplete, cut off from the world. Like an infant without it. That's how strong it is.
We now have access to knowledge and information whenever and wherever we want yet with all of this available to us, there seems to be little communication and development taking place. Is it technology itself or is it our conceptualisation of technology that needs to be addressed?
I don't know. I don't know it there's difference. Or if there is I don't see how I could know it. This is a step in evolution – and there's no way to see what the results will be right now, but some will need to be weeded out. We will adapt and I believe prosper from this transformation, but we'll change drastically, perhaps unrecognizably from what we were before. But we will survive I believe, but some of us won't make it to this next version of humanity. Maybe I am one of them. In fact, because I have not bred yet, I have no offspring; I am an evolutionary dead end. Maybe that's for the best I don't believe my genetics are fit for a completely technology automated society.
Is there some vital aspect of our humanity that we have lost to technology and the digital age? If so, given the abundance of technology and its dominance in modern society, do you think it can be regained?
I think there may be. But it may be replaced by something new, something I cannot possibly foresee at this point, though. And no, I don't think it can be regained. We are technology. I can say I am a primitive man, or that I'm de-evolved or something, but it's not really true. We all want to be unique, but I know I have more in common with the rest of humanity than I am different from them. Some people don't want to admit this, but unless you are a vegetable, or truly insane or dis-functional, you are probably more similar to the rest of the human race that you are different. The same things make me happy as do everyone else. I want comfort, love, security, habit etc… I am a man. But I'm not an ordinary man. Oh no no no no no no no no no.
Philosophy has a distinct presence in Slough Feg's music. Bertrand Russell's promisicuity gets a mention in the title of the first track on the new album and 1998's Twilight of the Idols referencing Nietzsche directly. Nietzsche is the one philosopher that metal musicians refer to more than any. His challenges to Christianity and morality, the übermensch, the transvaluation of values, as well as his attitude to art and creativity – that one should "write with blood" – all strike a chord with metal musicians. Why do you think this is?
Because he is obnoxious and contrarian and wrote a book called The Anti-Christ. Simple as that. Most people really do misunderstand Nietzsche in a lot of ways. But that's okay. He's fun to read whether you understand him or not. I'm more interested in his critique of the history of values, through his study of language. But then I'm a philosophy teacher, so I should assume everyone else is going to be interested in his academic pursuits. It's good enough that people like his metal qualities, which he does have in abundance. As for Bertrand Russell, he's about the most non-sexual man to walk the planet. That song is more a Heavy Metal version of 'Don't Stand So Close To Me'.
Slough Feg has been making music for about a quarter of a century and there have been significant changes in the industry during that time. Music has moved from radio to MTV and onto the internet. Do you see this as a positive development?
I don't know. Maybe. It's really hard to say. Like many I wish things were the old way, and have the 'sour grapes' attitude that if things were the way they used to be (i.e. if we were making records thirty years ago) then we'd be huge!!! But that's a ridiculous and unrealistic attitude to have. One thing that we had back then is quality control, at least a little more. Not everyone could make an album. But some really bad stuff still came out, and maybe now some good albums come out that might not have back them, so it's really hard to say.
The internet has had a colossal impact on music. Anyone can write a track, upload it and achieve fame (at least in some form), and anyone can access music anywhere in the world, either by paying for it or otherwise. What's your opinion of the internet's effect on music?
Because of the abundance of music available so readily, has music lost its value?
Sort of. I guess I might agree with this opinion. But again, I'm too much a product of my time to really know. I certainly do not know how exactly the internet is affecting music. I think it is making it worse, but it's so hard to be sure. Whatever the case, there is a lot of really bad stuff out there, and some good stuff too. The stuff that is making it, the hits and all that, are worse than ever I think. But there's always been bad popular music. I'd like to make hits, but there's no way to do that because the business is monopolised and insular. I don't know if that's because of the internet or not. Business took over some time in the eighties, big business. That killed quality popular music, for the most part. Now it does not matter at all how good it is, because someone realized they could sell anything with the right image and packaging, regardless of the sound. That's why the most mediocre bands of any genre are the biggest now – the blandest are the best. They are easily marketable. If you challenge marketability, forget it. If you are a clone of say, Sabbath, or Motley Crue, or whatever, you have a chance. Not a great chance, but a chance. Originality is out, for the same reason that if someone tried to sell a breakfast cereal that tasted like garlic, it would stand a chance. Well, maybe that's the best way to describe Slough Feg: we're like a breakfast cereal that tastes like garlic!!! Think you could sell albums that way?
There are a significant amount of bands that are producing music that is either a pastiche of or a homage to bands from the 60s through to the 90s (Black Sabbath, Led Zeppelin, etc.). Where bands were once celebrated for being ahead of their time, bands are now being revered for their capacity for imitation rather than innovation. Has music come full circle? Is originality in music possible?
Wow, you read my mind in this question, but I believed I answered it. Maybe we are pastiche. We do sound pretty seventies. Like I said above, originality is possible, but it might never see the light of day – or, it certainly wouldn't reach a wide audience. People buy what they're told to buy. That's human nature and it's not going to change. So if you wanna sell albums, start imitating!!!
Back to the band, Slough Feg have been making music since the early 90s. With so many releases behind you, how do you avoid repeating yourself?
I don't. I repeat myself quite often.
What does the future hole for Slough Feg? Any plans for shows? If so, will we be seeing you in the UK?
Not sure when, we've had trouble with working papers over there. I can't really come back until we have proper documentation, it's too risky. But the UK is my favourite place on the planet. Seriously.
Slough Feg website
Slough Feg on Facebook
Jason.Guest


Three recent, somewhat obscure news stories highlight the richness and diversity of nefarious activities undertaken in the shadows of cyberspace.
These stories also illustrate some ways in which the perpetrators exploit human emotions (e.g., fear and enthusiasm) and net resources (e.g., search engine optimization and social networking applications) to carry out their insidious schemes.
But perhaps of most importance, these three stories serve as a reminder that every 24 hours in cyberspace, there is something else to use as grist for the mills of user awareness and education. Cybercrime is 24x7 and global, user awareness and education should also be 24x7 and global.
Here are brief excerpts from all three, with links to the full texts and to relevant reports.
According to the latest MarkMonitor Brandjacking Index, cybersquatting grew by 18 percent in 2008, proving that it continues to be a lucrative mode of exploitation, according to MarkMonitor officials. ... MarkMonitor's research found a total of 440,584 instances of cybersquatting were identified in Q4, followed by 86,837 instances of false association and 33, 614 instances of pay-per-click abuse.
To read MarkMonitor's Brandjacking Index, click here.


Can't wait!! Very excited for Danny to do his solo tour. Looking forward to a great night out with the girls!
Please come to St. Louis, MO, I missed the Main Event because I was in the hospital having emergency surgery!!! I was so mad!!! I have been a BH from the beginning & I always will!!! Love NKOTB & can't wait for your new tour!!!
More cities please! Dayton, Ohio!
Hey Danny! Did I miss the Miami performance? you have to give us home girls a chance to sit in on a set! My girls loved you in Virginia!
Hey Danny PLEASE PLEASE PLEASE come to Nashville Tn..
The executive chef here was a genuinely nice person and never made us feel like we were just "business" for him. He was extremely competent and organized. Because of the natural beauty of the event space NYC, we were able to get away with very minimal decorations.


A reader responds to the Coding Corner on malnutrition, published in our January issue.
I read with great disappointment and concern the article "Malnutrition revisited" by coding columnist Richard D. Pinson, MD, FACP, in the January 2017 ACP Hospitalist.
I would agree that accurate coding data and adequate evidence to support it are critical for medical coders and to help direct patient care improvement and patient safety efforts. This article, however, provokes doubt and confusion rather than clarity about sincere efforts to collect accurate evidence to support diagnosis and coding of protein-calorie malnutrition as described in the Academy of Nutrition and Dietetics and American Society for Parenteral and Enteral Nutrition 2012 Consensus.
As the article states, ICD-10-CM codes of moderate and severe protein-calorie malnutrition do not differentiate among acute, chronic, or social or environmental circumstances. The ICD-10 therefore addresses only severity and not current clinical knowledge describing malnutrition types. Use of the code E63.9, as the article suggested, is therefore completely unhelpful as it does not differentiate types nor does it elevate the seriousness of severe or moderate types. There is great difference clinically. Treatment and intervention are safely determined only with knowledge of the type of malnutrition.
The metabolic state greatly impacts feeding regimens and the ratios and timing of nutrient combinations. Delivered incorrectly, inappropriate nutrient ratios can cause death and metabolic imbalances. The severity and type of malnutrition are therefore both critical pieces of clinical information and should not be dismissed to a single non-MCC or non-CC code.
Many professionals have spent careers trying to better understand nutrition diseases and to clarify diagnoses in order to enable diagnosis and coding for an honest evidence-based assessment of the extent of malnutrition, all to better act and intervene at appropriate levels with our limited resources. This article does not recognize the depth of this effort and these clinical findings.
Note: Ms. Scollard is a contributor to Academy of Nutrition and Dietetics and American Society for Parenteral and Enteral Nutrition 2012 Consensus and her opinions do not necessarily reflect positions of her employers or professional organizations.
Dr. Pinson responds: I thank Ms. Scollard for her letter, and I certainly appreciate her point of view. Malnutrition has always had diagnostic, therapeutic, and coding challenges. As I mentioned in my column, while much of the Academy of Nutrition and Dietetics and American Society for Parenteral and Enteral Nutrition 2012 Consensus has merit, I have concerns about its subjectivity, certain inconsistencies, and potential compliance risks, and I believe my column properly discussed these concerns. In my view, a critical, rational analysis of any proposed new definitions and criteria is valuable. I look forward to future debate, discussion, and research on this issue that may address both my and Ms. Scollard's concerns.


This is my daughter in a Homemade Owl in a Tree Costume. I purchased fabric that looked like a tree trunk and I glued it to cardboard. I cut holes for her head and arms. On the inside of the cardboard I hot glued stems with leaves on them and then I covered the backside with tan felt to cover up the bottem of the tree stems. I purchased iron on Velcro strips to close the back and I used that so it would make easy access to put it on and take it off. The mask was made by purchasing an assorment of brown, tan, black and white feathers and I then glued them to a mask that was purchased at the craft store. Hope you enjoy.
Homemade costume idea posted by Amy J.


The Department of Obstetrics and Gynecology's Office of Education is committed to exemplary graduate and undergraduate medical education.
To provide leadership and support in curriculum development, program evaluation and educational consultation to our faculty, fellows, and residents.
To provide needed educational support services for faculty, fellows, residents, and medical students with emphasis on maximizing the overall educational experience and achievement of specified learning outcomes as well as promoting life-long learning skills.
To utilize sound principles and practices of adult education in our programs, services and activities.
To ensure sound management practices, ethical conduct, competent faculty and adequate resources are available to successfully implement programmatic decisions.
To produce nationally recognized curricula, assessments and outcome benchmarks in medical education.
To assume a national prominence in educational research that informs our practice.
Read more about the UAB Ob/Gyn Fund for Excellence in Education. . .


Now, My Costume Wigs, offers a discount version of our best selling wig with the same bright colors and high quality material but with a price to fit all budgets. Now everyone in your group can wear this wig with money to spare.
From purple to green to every color in between, you'll be able to find the perfect troll wigs for your troll costume and a matching one for your pet! With the largest troll wig selection online we have troll wigs for kids and adults alike.
Check out My Costume Wigs for the largest troll wig selection online - you won't be disappointed.


To follow up on my previous article entitled "My Poncho Upgrade" I decided to spend a night in the woods using my poncho as a shelter. The fiberglass "X" frame mounted inside converted the rain gear into a shallow dome tent.
I carry this in my Bug-Out-Bag (BOB) along with a sheet of water intrusion barrier material that I use for a ground cloth. I don't carry a mattress so I selected a spot that had a layer of leaves that I hoped would be sufficient to provide enough thermal insulation from the ground in addition to some degree of comfort to lay on. It was also quite flat as I try to avoid an inclined surface to sleep on.
For the most part I laid on my side with my knees bent as if sitting on an imaginary chair. Alternatively I would straighten my legs and sleep on my back. Because it wasn't raining I knew that I could afford to poke my feet out from under the shelter if needed but I could have changed from a sitting position to a "V" position if needed to be completely covered.
The "X" frame inside provided a nice place to hang my key chain light, but my smart phone provided plenty of light when needed inside the shelter. I moved my pocket knife from my side to a more comfortable position in my shirt pocket with the added benefit of quick access if needed. I also used a bug net over my head at night, keeping it extended out from my face. As an added bug/critter repellant I rubbed tea tree oil on my ankles, wrists, neck, and forehead.
The only thing that I used that I don't currently carry in my BOB was a down sleeping bag. This causes me to rethink my strategy and perhaps consider preparing different BOBs based on the circumstances that would necessitate my emergency egress.
This entry was tagged BOB, Bug-Out-Bag, Camping, Poncho, Shelter, Tent. Bookmark the permalink.


text:
Nets assistant gets $10K fine for play interference
NEW YORK — Brooklyn assistant coach David Vanterpool was fined $10,000, and the Nets were penalized $25,000 by the NBA on Thursday after he interfered with play in a victory at Washington.
Vanterpool reached across the sideline and deflected a pass with 5:42 remaining in the fourth quarter of the Nets' 119-118 victory on Wednesday. The Nets ended up coming up with the ball and were credited with a steal.
Washington's Kyle Kuzma, who was charged with a turnover on the play, was livid and critical of the officials after the game. Referee Ben Taylor said none of the officials saw the deflection on the floor.
Henderson goes wire-to-wire at LPGA opener
Sharks send Nieto back to Avs in 4-player trade
Brothers land in penalty box with parents on hand


Download "SUNRISE CONDOMINIUM ASSOCIATION AKA SUNSCAPE VILLAS REVISED RULES & REGULATIONS APRIL 2014"
MOVING 1. An owner or tenant shall reserve with the property manager, giving the date and time of the anticipated move. 2. At the time of the move, the owner or tenant will be allocated the "locked out"
SAVANNAH CROSSING CONDOMINIUM ASSOCIATION 2009-2010 HANDBOOK 2738 W. Tharpe Street Tallahassee, FL 32303 BOARD OF DIRECTORS August 2009 July 2010 All board members can be reached directly through management.
Bois Du Chene Condominiums Homeowner s Welcome Packet Dear New Homeowner, The Bois du Chene Homeowners Association, Inc. would like to take this opportunity to welcome you and your family to our community.
Strata Corp BCS 1676 14 Royal Avenue E. New Westminster V3L 5W5 RULES A. Use of Strata Lots 1. Owners/Occupants are responsible for the behaviour and control their children and children of their guests.
Springfield Farms MHC is an equal housing opportunity community and Prestwick Properties LLC is an equal opportunity housing provider.
s Name: Unit #: Address: These Rules and Regulations serve as an attachment to the Lease between Management and you. Compliance with these Rules is an obligation of tenancy and violation may lead to eviction.
LOT LEASE AGREEMENT. This Lease Agreement ( Agreement ) is made and executed by and between ( Lessor ) and / ( Lessee or Resident ) on.
RULES AND REGULATIONS FOR SANDPIPER COVE II AT BOTANICA CONDOMINIUM ASSOCIATION, INC.
5) RENT: The rental fee for the Premises will be per semester, per academic year.
STUDENT HOUSING LEASE AGREEMENT DATED 1) PARTIES: The parties to this Agreement are Advanced Housing Management, LLC, hereinafter called Leasing Agent and the persons below signed, hereinafter called Tenant(s).
CLUBHOUSE RENTAL AGREEMENT DATE: At your request, we are sending to you a current Clubhouse Rental Contract with Rental Rules.
COMMUNITY POLICIES Table of Contents Introduction... 2 I. Personal Property... 2 II. Decorative Items... 2 III. Flags... 2 IV.
WELCOME TO HILLIARD COMMONS! We hope that you find your new condominium lifestyle to be satisfying and rewarding.