Subliminal Fear – Escape from Leviathan

Subliminal_Fear-cover640
Subliminal Fear is a five piece band from Barletta, Italy. ”Escape from Leviathan”, which is their third album, will be released on the 13th of May through Inverse Records. I’m a newcomer to this band. First of all i have to admit, what draw my attention here is the album’s artwork. In my opinion it is beyond great. It is symmetric as it is dark and obscure. It was made by Seth Siro Anton. Let us get back to the album though. You can find ten tracks inside this album. The band’s music is a blend of melodic death metal and industrial metal. To my ears, for some reason, it souds a bit nostalgic. I think, 90’s metal kids will feel me. In my opinion, ”Escape from Leviathan” could easily be the soundtrack to some sci-fi movie like blade runner for example. Listening to this album made me think of dark, mysterious, post-apocalyptic sceneries. The way i see it, you need to listen to this album many times because this is the only way to discover all of its secrets and richness. You’ ll find many cool songs here. The ones i’ ve singled out are ”Nexus”, ”Limitless” and ”Escape from Leviathan”. Must i say i enjoyed this album. Specially recommeded for fans of Fear Factory, Mnemic, Front 242. Check out these links:

Advertisements

Interview with Walk Through Fire

rep-01-hi
Please introduce your band. When was the band formed?

We started up in 2008. Me and a friend had a project which was some kind of dark, crust punk oriented music in the veins of HIS HERO IS GONE. But one of the demos I did for that project stuck out from the rest and we decided to go a different direction. Long story short – that was the starting point of Walk Through Fire.

Can you tell us about your main influences?

Historically we have been influenced by many bands and artists to get where we are now, but today it’s hard to say if any specific band or artist influence us directly. At least when it comes to the actual music. We’re big fans of BOHREN UND DER CLUB OF GORE, SWANS, ANGELO BADALAMENTI, ARVO PÄRT and much more, but we don’t let everything INTO OUR MUSIC, you know?

How would you define your sound?

First of all I think what is different with our sound compared to other bands in the SLUDGE/DOOM scene, is that we don’t base our music on ”riffs”. We never write shit based on the pentatonic blues scale like a lot of bands in the genre. Instead, we often base our songs on systematic chord progressions and structures, sometimes written on a piano or organ. Very minor chord oriented.

Another important thing for our sound is that we never use effects such as reverbs and delays. A lot of artists hide behind their effects to make things sound bigger and more atmospheric, and sometimes it just feels lazy. Especially on the vocals. Some vocalists can’t scream for shit, so they put a one minute long reverb on it.

band-01-hi
In 2014 you released ‘’Hope is Misery’’ Lp. How did the recording sessions go and how has the reception been so far?

We recorded it live in the studio. All except the vocals, which I recorded at a later stage. Mostly because I had a lot of bad shit going on and put myself under a lot of pressure to get the album ”right”. I think I re-wrote some of the lyrics close to a hundred times – changing a line here and a word there, just to change it all back again each twentieth time or something. But I got it right in the end..

The reception has been good. I mean, we know that the music is just annoyingly boring for a lot of people and that’s cool. We’re not that cool sludge band, playing at that cool festival. It’s about feelings. Shitty feelings. I think people who like this album, really listens to it as we do, you know? Maybe they go through their own shit, walk through their own fires. And If so, I hope our music can be an outlet for those feelings, as it is for us.

Any particular concept behind ‘Hope is Misery’’ you would like to discuss?

We tried to create music that was pitch black. And I think we achieved that with ”Hope Is Misery”.

What inspires you the most?

Human suffering.

What are you listening to these days?

Lately I’ve listened a lot to THE CURE albums ”Faith” and ”Seventeen Seconds”. Drony, melancholic, monotone, simple. Other than that it’s the usual mix of metal, punk, hip hop, electronic music…

Any live shows planned for this year?

Only one in the calendar: 7th of May at the NORTHERN DISCOMFORT festival in Copenhagen. But we do have some other shit going on, but we’re not ready to announce anything about that yet..

What does the future hold for Walk Through Fire?

A lot of broken amps and cymbals.

Wode -S/T

wode cover art
Hi everybody. We’ re back today with another review. Wode is a three piece, black metal band, formed in Manchester, U.K back in 2010. Their self titled, full length, debut album will be released on the 8th of April via Broken Limbs Recordings. Six tracks are included in this album.

I’ve been listening to this album for some time now. Inspired by the norwegian scene but also by bands like Wolves in the Throne Room these guys here deliver pure black metal. ”Wode” sounds atmospheric and ultra-heavy at the same time. You can also trace a certain sense of epicness here. For example, check out ”Trails of Smoke”. Really nice track no doubt. ”Plagues of Insomnia” contains some really nice riffs as well as cool heavy, guitar solos. Personally, my favorite one is ”Cloaked in Ruin”. Hands down, this is a great track where black metal and heavy metal blend ideally. To be honest, i liked all of their songs.  Listening to this album i was like ”O.k gentlemen, you’ ve got my attention”.

I must admit i enjoyed this album. Therefore i would like to recommend it. Specially recommended for fans of Satyricon, Enslaved, Wolves in the Throne Room. Check out these links:

Redis data structure change notifications

Hi all,

everyone knows Redis, right? Redis is an open source (BSD licensed) data structure server with extended pub/sub features, allowing applications to subscribe in Redis channels & be able to be notified when a channel update occurs, while other apps (in the other side) generate the updates, publishing their update in particular Redis channels.

Although, in this post, i am already assuming that you are familiar with Redis and already know how to code a script that publishes to/subscribes in a channel, & you already know how to manipulate some of Redis data structures, such as the Hashes, the Sets & the List.

We are interested in receiving data structure updates in order to know that something has changed & if our app is interested in that particular change, then it should do something useful with it. In addition, we would like our app to be interested in only one specific data structure of redis, one specific structure that holds data of interest for our app.

Redis supports pubsub for channels but, can a data structure has its own channel? Yes, by using Redis Keyspace Notifications, from version 2.8.0. Thus, when a data structure update change occurs, a Redis event is generated & propagated through the channel. Your app just needs to listen to that channel in order to be notified about the event.

The name of that particular channel is formed as : __keyspace@0__:" "data structure name"Thus, if your app is interested in that specific list named “registeredArtists“, then your app should subscribe & listen to the channel __keyspace@0__:registeredArtists.

Demo

Requires:

  • linux
  • redis
  • Python
  • python-pip redis module

1.1 Client

In order to show you the functionality, i prepared a small Python demo for it:

from redis import StrictRedis
from time import sleep
from sys import argv  def show_msg(msg):
 print ‘Latest List Operation =>’,msg

 def listen_for_data_structure_operations(dt_key,host=‘localhost’):
     redis = StrictRedis(host=host)
     s = redis.pubsub()
     s.subscribe(**{ ( ‘__keyspace@0__:%s’ % dt_key) :show_msg})

    while True:
         msg = s.get_message()
       if msg : print msg
         sleep(1)

if __name__ == ‘__main__’:
    if len(argv) > 1:
          key = argv[1]
    else:
          key = ‘alist’
      listen_for_data_structure_operations(key)

 

If you run the code with argument the name of a redis data structure, your script will subscribe to the channel of changes/operations applying in that particular data structure. The data structure does not necessarily need to exist in order to subscribe to it.

 gclkaze@tzertzelos:~/Tzertzelos/Redis$ python dtUpdateTest.py registeredArtists
{‘pattern’: None, ‘type’: ‘subscribe’, ‘channel’: ‘__keyspace@0__:registeredArtists’, ‘data’: 1L}

1.2 Server

Now, use the terminal to connect to redis, and

gclkaze@tzertzelos:~/Tzertzelos/Scriptz/Redis$ redis-cli
127.0.0.1:6379> LPUSH registeredArtists “Motorhead”
(integer) 1

OK, our new list named registeredArtists has length equal to 1, and its only element is the string Motorhead.

1.3 Client-side update

The notification generated after the LPUSH in the server should be visible in the client side!

gclkaze@tzertzelos:~/Tzertzelos/Scriptz/Redis$ python dtUpdateTest.py registeredArtists
{‘pattern’: None, ‘type’: ‘subscribe’, ‘channel’: ‘__keyspace@0__:registeredArtists’, ‘data’: 1L}

Latest List Operation =>  

{‘pattern’: None, ‘type’: ‘message’, ‘channel’: ‘__keyspace@0__:registeredArtists’, ‘data’: ‘lpush’}

Yea! Our client was able to capture the event generated by the LPUSH that applied to the list that resides in the server.

Redis’ pubsub feature really simplifies the implementation of a push mechanism between theserver & the app, that is actually a core feature of the system.

Now go & experiment with Redis!

kazeone

Linx

An introduction to Redis data types and abstractions

Redis Commands

Redis Keyspace Notifications

Musix

Truckfighters – Gravity X (2005)

The War Goes On -The War Goes On

a0870443884_10
The War Goes On is a four piece punk band from Copenhagen, Denmark. The band was formed back in 2008. Their new self titled, full length album will be released on the 18th of April. Here you will find eleven tracks of pure, uncompromised punk rock. To my ears it sounds as raw and energetic as it should be. Their lyrics deal with society and everyday shit that we’ re going through. I do not wish to single out a favorite song here. I must admit i liked all songs. In my opinion, these are very well written songs that will speak directly to your heart. Their motorhead-charged punk rock made my day and i think it will make yours too. Check out these links:

Python function invocation from C++

Hi there,

today ‘s mission is to load a Python module & call a module function from C++ by using Python’s C API. OK, that is cool, but why should we do that? Why not just rewrite our Python modules on C/C++ & perform the job in a native way?de

  • well because you are going to lose a significant amount of time in order to rewrite the module(s), test them & verify that everything is fine
  • to rewrite a small python module in C/C++ is fine, but what if you just want to use an existing functionality already implemented in Python? Let’s not reinvent the wheel!
  • you really want to just use the module & treat it as a black box. Implementation details about the module’s functionality may be way too out of subject. Let’s keep the requirements simple!

Let’s put some nice music (all tracks/artists that were listened & contributed to this production are provided in the Musix session) & start our experiment!

Setup

The code has been developed on Ubuntu Linux, and the dependencies are the following

  • C++ 11
  • Python 2.7
  • Python-dev :
    gclkaze@tzertzelos$: sudo apt-get install python-dev

Assumptions

Just to be clear & precise:

  • we are not taking into account multi-threading; consider a case where our program loads a module & attempts to call some Python functions in an multi-threaded manner, we do not guarantee that the parallel function calls will succeed.
  • for now, all test Python functions that accept an argument or arguments, all arguments will hold integer values.
  • didn’t check at all exception handling (a nice TODO)

Our test module

spam.py

def foo():
    print ‘Foo’
    return 6
def foo2(x,y):
    print ‘Foo2’
    return x*y

 

Steps

0. Our class, the PythonInterpreter class

The following snippet depicts the PythonInterpreter class, responsible for loading & calling a requested Python function from a given module.

#include <Python.h> // The Python (Interpreter) C API
#include <iostream> // for std::cout printing utility
#include <vector>
#include <string>
#include <utility> // std::pair
#include <map>

namespace Interpret{
    //Some enums for error checking
    enum InterpreterStatus{
        OK = 0,
        FUNCTION_NOT_FOUND = -1,
        MODULE_NOT_FOUND = -2,
        RETURNED_NULL = -3,
        NOT_CALLABLE_OBJECT = -4,
        UNKNOWN_ERROR = -5,
        ARGUMENT_ERROR = -6,
        UNKNOWN_INTEGER_ERROR = -7
    };

    class PythonInterpreter 
    {

    private:
        // The sys.path Python module need to be imported, and add the current
        // directory in the path in order to run the Python Interpreter 
   	std::vector<PyObject*> m_Globals; 
        PyObject * m_CurrentModule = nullptr; // The current loaded Python module
        // The dictionary object of the current loaded Python module, 
        //contains module namespace information, such as module functions,
        // module globals etc 
        PyObject * m_CurrentTable = nullptr; 
        // We need to create this from a string containing the 
        //module's name, in order to import the module later.
        PyObject * m_CurrentModuleName = nullptr; 
        bool m_Initialized = false;
        std::map<std::string, std::pair<PyObject*, PyObject*>> m_LoadedModules;
    public:
        PythonInterpreter(){}
    };
};

After we have instantiated our PythonInterpreter, we would like to be able first load our Python module, and if everything goes fine (that particular module exists for instance), we would like to specify a particular module function, load the module, pass the arguments (if it accepts any) and call the function.

1. Load Module

InterpreterStatus PythonInterpreter::loadModule(const std::string& module)
{
    if(!m_Initialized) {
        Py_Initialize();
        addCwdInPythonPath();
	m_Initialized = true;
        //std::cout << "PythonInterpreter initialized!" << std::endl;
    }
    //If the module isnt here yet, or the same module has being loaded earlier,
   // load it
    if(m_LoadedModules.find(module.c_str()) == m_LoadedModules.end() ) {
        //std::cout << "Module init" << std::endl;
        m_CurrentModuleName = PyString_FromString(module.c_str());

        // Load the module object
        m_CurrentModule = PyImport_Import(m_CurrentModuleName);

        if(!m_CurrentModule) return MODULE_NOT_FOUND;
        // m_CurrentTable is a borrowed reference 

        m_CurrentTable = PyModule_GetDict(m_CurrentModule);
        m_LoadedModules[module] = std::make_pair(m_CurrentModule,
                                              m_CurrentModuleName);
    }
    else {

    	m_CurrentModuleName = m_LoadedModules[module.c_str()].second;
    	m_CurrentModule = m_LoadedModules[module.c_str()].first; 
        m_CurrentTable = PyModule_GetDict(m_CurrentModule);

    }
    return OK;
}

1.1 Add current working directory in the Python path lazily

The first call to loadModule will call Py_Initialize in order to prepare the Python interpreter’s runtime in order to accept the subsequent Python C API calls and add the current working directory to the Python’s Path, by calling the class method addCwdInPythonPath that is depicted here.

void PythonInterpreter::addCwdInPythonPath()
{
    //The following is equivalent to:
    //from sys import path
    //path.append('.')
    PyObject *sys = PyImport_ImportModule("sys");
    PyObject *path = PyObject_GetAttrString(sys, "path");
    PyList_Append(path, PyUnicode_FromString("."));
    m_Globals.push_back(sys);
    m_Globals.push_back(path);
}

This step is of great importance, if it is omitted, the Python runtime won’t be able to know where to find our Python module (spam.py). If the module lives in a different directory, well, we will need to add it in our Python path by using a variation of the previous method.

 

1.2 Store loaded module pointers in the map

In the Python C API, every Python object (module, function, string, integer, float, list, dictionary) is treated as a PyObject, then based on type checking, we treat each of them differently (as a module, string, integer, float, dictionary & so on).

In our class, we are using a map of strings<=>PyObject* in order to know which modules have been already loaded in the past, allowing us to omit loading a module that has already being loaded in the past.

Thus, we first need to check if the requested module exists in our map, if not we should try to load it and then add it in our map. Otherwise, we load its PyObject* from our map.

2. Call Module Function

2.1 Pass the argument to the Python function

We will need to pass the integer arguments (if any) to the Python function. In order to do that, we will need :

  • first to create a Python tuple list with size equal to the amount of marshaling arguments by using PyTuple_New
  • iterate our string argument vector,
  • for each argument, extract its integer value and set it to our argument tuple list by calling PyTuple_SetItem

The PythonInterpreter::setFunctionArgs performs the previous operations & returns a filled PyObject* tuple list that will be used in our function invocation.

PyObject* PythonInterpreter::setFunctionArgs(const std::vector<std::string>& args)
{
    int argsN = (int)args.size();
    auto pArgs = PyTuple_New(argsN );
    PyObject *pValue = nullptr;

    for (auto i = 0; i < argsN ; i++) {
        pValue = PyInt_FromLong(atoi(args[i].c_str()));
        if (!pValue) {
            PyErr_Print();
            return nullptr;//UNKNOWN_INTEGER_ERROR;
        }
        PyTuple_SetItem(pArgs, i, pValue);  
    }
    return pArgs;
}

 

2.2 Call Module Function with arguments

The PythonInterpreter::callFunction takes as arguments the name of the function that we want to call and a list of string arguments that will be passed in our call.

InterpreterStatus PythonInterpreter::callFunction(const std::string& function, 
                               const std::vector<std::string>& args)
{

    PyObject* currentFunction = PyDict_GetItemString(m_CurrentTable, 
                                                    function.c_str());
    if(!currentFunction) return FUNCTION_NOT_FOUND;

    if (PyCallable_Check(currentFunction)) {
        PyObject *pValue = nullptr;
        // Prepare the argument list for the call
        int argsN = (int)args.size();
        if( argsN > 0 ) {
            auto pArgs = setFunctionArgs(args);
            if(!pArgs) return UNKNOWN_INTEGER_ERROR;   
            pValue = PyObject_CallObject(currentFunction, pArgs);
            if (pArgs != nullptr) {
                Py_DECREF(pArgs);
            }
        } 
        else {
            pValue = PyObject_CallObject(currentFunction, nullptr);
        }

        if (pValue != nullptr)  {
            printf("Return of call : %d\n", (int)PyInt_AsLong(pValue));
            Py_DECREF(pValue);
        }
        else {
            PyErr_Print();
            return ARGUMENT_ERROR;
        }
    } 
    else {
        //std::cout << "Cant call it" << std::endl;
        PyErr_Print();
        return NOT_CALLABLE_OBJECT;
    }
    return OK;
}

We first need to check if the requested function is included in our module’s table, which we saved in the previous step, while calling PythonInterpreter::loadModule.

If the function is not included in the module, ofc we won’t be able to call it. Thus, we return a nice & precise FUNCTION_NOT_FOUND.

Otherwise, we will check if there are any arguments & if any we will set up the tuple list holding our integer arguments (by calling PythonInterpreter::setFunctionArgs) & finally call PyObject_CallObject by passing the argument tuple list. If there are no arguments to be passed, we will just call PyObject_CallObject with a nullptr as tuple list.

After the call to the Python function, the variable pValue will hold a reference to the return results of the Python function. In our case, after calling “foo()“, pValue will store the return value “6”. After calling “foo2(2,4)”, pValue will store the return value “8”. Because pValue is a PyObject*, we will need to cast it to int by using PyInt_AsLong in order to retrieve the integer value, that is the result of our function call.

After executing the function call, pValue along with the tuple list that we created earlier (if there were arguments) will need to be  cleaned by calling Py_DECREF, marking them as not needed anymore, allowing the Python run-time to garbage collect them.

3. Cleaning stuff up

Before destroying our PythonInterpreter instance, we would like first to clean up our stored PyObjects such as the ones storing the “sys” module & the “path” modules (filled up after the call to pythonInterpreter::addCwdInPythonPath in step 1.1 ) & the module pointers stored in our module map.

void PythonInterpreter::cleanUp()
{
    // Clean up
    //std::cout << "Destroying " << m_Locals.size() << " locals" << std::endl;
    for(auto var : m_LoadedModules) {
        Py_DECREF((var).second.first);
        Py_DECREF((var).second.second);
    }

    m_LoadedModules.clear();
    //std::cout << "Destroying " << m_Globals.size() << " globals" << std::endl;
    for(auto &var : m_Globals) {
        Py_DECREF(var);
    }
}

PythonInterpreter::~PythonInterpreter()
{
    cleanUp();
    // Finish the Python Interpreter
    if(m_Initialized) {
        //std::cout << "PythonInterpreter destroyed!" << std::endl;
        Py_Finalize();
    }
}

After the previous step, we can stop the Python run-time safely, by calling Py_Finalize, which deallocates all the memory of the Python interpreter in the C API side effectively.

4. Call them!

4.1 demoMain.cpp

#include "demo.h" // Contains the version of PythonInterpreter, that was used for this demo
#include <assert.h> // Our favorite buddy

int main(int argc, char** argv)
{
    auto py = new Interpret::PythonInterpreter();

    //import spam
    auto res = py->loadModule("spam");
    assert (res == 0 );

    //spam.foo2(1,3)
    res = py->callFunction("foo2", {"1","3"});
    assert (res == 0);

    //spam.foo()
    res = py->callFunction("foo", {});

    assert (res == 0);
    return 1;
}

 

4.2 Compile them

gclkaze@tzertzelos:~/C++/CallPythonFromC$ make demo
g++ -std=c++11 -Wall -o demo -g -I/usr/include/python2.7 demoMain.cpp demo.h -lpython2.7

4.3 Run

gclkaze@tzertzelos:~/C++/CallPythonFromC$ ./demo
Foo2
Return of call : 3
Foo
Return of call : 6

You just called foo & foo2 functions of the Python module spam from C++ using the Python C API. Congratz!

I hope you enjoyed this tutorial, i am providing the demo’s code & the full version of my class in github (i am providing the link below). The canonical version of the class contains all showed code plus some extensions for verifying your data returned by the Python function call & not done functionality for handling the results in a threaded manner (many calls, many threads, many results).

Now go extend your C++ base with your existing Python utilities,

cheers

kazeone

Linx

Musix

 

Deathspell Omega – Paracletus

a3877984834_10

A friend of mine asked my opinion about the lastest Deathspell Omega album. Well, dear friend since you liked this album let me just state that my opnion is rather unnecessary. But if you want a review then i’ll give you one.

Dear friend you were right. This album is pretty damn’ good. But let’s begin this review in a more proper way. Deathspell Omega is a black metal band from France. Very little is known about this band and that’s because they retain a rather obscure profile. ”Paracletus” was released back in 2010. You can find ten tracks in this album. These ten tracks form an album of avant garde, dysfunctional black metal. It is rather raw and dark and a bit jazzy (sometimes) and atmospheric at the same time. One thing that made an impression on me is the album’s production. Pretty damn’ impressive. In my opinion it helps you a lot to discover this eerie soundscape called ”Paracletus”. I consider ”Paracletus” to be a concept album. O.k, this is obviously an assumption of mine. First track is called ”Epiklesis”. In greek it means invocation. And it ends with ”Apokatastasis Panton” which in greek means recovering of everything. This album is like a pray to a dark deity. So dark and mysterious at the same time.

Personally i enjoyed this album. I want  to thank my friend for his recommendation. You know who you are. This album is definitely recommended for fans of Ved Buens Ende, Arcturus, Thorns, Satyricon, Fleurety. So if you’ re a fan of these bands do yourself a favor and listen to ”Paracletus”. Check out these links: