apleben.com

Partial Formalizations and the Lemmings Game

Alexander Pupeikis — Fri, 02 Dec 2011 10:29:42 +0000

~~Yesterday~~ Oh man, this is so hard each time to found out a way of the paragraph or topic start. Nonetheless, I am not a novel writer and doing this how I only can.

An intentions of this post is my attempt to express some nifty tricks, that I learned from other languages by reading a source code of many glorious Open Source projects, that were written on those languages, as well as writing on such languages. Among these languages are Scala, Python, C++, Emacs Lisp and I barely looked at Clojure. So, will try to apply something to Java as a non Phantom equation.

Oops, must to mention what picture to this post was proudly stolen from the CoderWall’s achievements badges. I am so sorry (And this is not a promotion, if you cares about it).

What Needs to be Formalized?

This is a point for a daringly cantankerous and short digress.

In the era of the growth popularity of many “modern” Programming languages people still (and always will) complain about them, by rupturing between these friends forward and backward. Personally, I will try to not fall to this curve and will try to express my objective position without any fanaticism.

First of all, should mention, that I still think and believe, what many people trying to apply their knowledge in one sole language into another languages as well, even scarcely ever looking on the second. Previously, most people never use C++ in the right way, how it could be used. Instead, they’re always tried to use C++ as a glorified C or slightly mutated Java. And this is not the right way to use it. Without any doubt, nobody should call himself a professional, if he only knows one language. Many of these words were expressed by Bjarne Stroustrup in his interview to bigthink.

Meanwhile, a total annihilation between two armies of ~~zombies~~ Javists and mutated Javists (actually, absolutely immutable) are proceeding in the full-length. A first army stands with a flag emblem framed like “Senior Java Geeks” and “Java NOT dead… yet (author’s note)”, the second army holds a flag with emblem framed “Scala type spelunker” and “Clear your mind – this is Clojure”. For some unsubstantial reasons, the second army also periodically suffer from civil wars in their seemingly slim ranks. Also, we could find a third not numerous army of slightly mutated Javists, which not hold any flags, but if they will… their flag would be embraced with a frame “This is Groovy Baby”. In addition, sometimes we even could notice a migration from the third army to the second with a fast-forward merge strategy.

As for me personally, I am not prefer one of these intrinsic locks and prefer to stay apart from it on the hill and observe how they will smash each other. Because I think, that it is much better to hold a finger on the proverbial ”Red button”, instead of fighting with a naked sword in your hands. However, I like Scala as a language and as a good step forward, but without deep fanaticism and contempt to others.

Objects in Space in the Lemming World

Most people seriously complain about Scala and his over-complexity, about lack of many features in IDEs, that they prefer to use for their Java coding, etc. Geometric position of these objects and their relations comes from the Java world, where people has and most importantly wish to have an IDE, that will solve many problems in the code for you. This is a such evil kind of automation tools, although many people will never admit this – it is a bitter truth of reality, when you are willing to press an “apply button”, instead of just think about a problem and learn from it, when you solved it. You will just pass it away. This is are persistent behaviors of people, who comes to Scala and / or Clojure world with an attachment from the Java world, especially without any background with another languages.

Not everybody knows that the most influential language in this world is C++ (surprise~!). Probably, the most famous utility, which everybody use every day are – Google search engine (or your search engine of choice). Yes, it is C++. Recently (don’t remember when, though) Facebook turns into C++, because they need performance for their backend. Your entire desktop is C/C++ (Cocoa, CoreAudio, CoreData, CoreLibs, KDE… many of them) as well, etc., etc.

Even by living a such long life, C++ developers still do not have a good qualified IDE and many commercial companies aren’t interested to spent their time and resources into development in this area. Not because of the “language popularity”, contrariwise, because of benign of such developers and most of them don’t need a “by one button apply” solutions, as well as a complexity of the language themself. Many people always complain about it too. It’s just too hard to build such IDE that would be as good as for Java right now. Java is a much simpler language themself.

Much of the relative simplicity of Java is – like for most new languages – partly an illusion and partly a function of its incompleteness.

Apparently, Scala is a such type of complex language, where you have a lot of constructions and language rules, and I guess, not just to create an encumbrance around it or to stir up envy from the Java fans. I think, it were made to gain an immediate efficacy and to destroy excruciating pain in the back port of your body. Such type of language just cannot be simple and tools creation for it are even harder. Seems like, it’s such kind of fervency, when people complain about it, albeit don’t understand the entire problem completely.

Physics of the Common Sense Lemming World

Moreover, most people complain, that they just cannot read a source code of Scalaz project, source code of xsbt project and another projects, after just a three or even six months of writing some Scala code, straight-forward and right away. Likely, with a total absence of any experience in the pure functional programming languages, among them Haskell, OCaml, Erlang and others. Is it a so new kind of hypocrites?

Aforementioned libraries have been made definitely by a cunning and biting wit, by a guys those have a lot of experience in Haskell, and most of theoretical background came into Scalaz and xsbt from Haskell and math theory. If you are not familiar with it, how you can even try to read this code? It is initially wrong decision.

Sure, such libraries not without their own crankiness, but it is not just an attempt to make a lesion for your brain, conversely this is an attempt to solve a problem in another way. Don’t understand – don’t read the code, but use it. It could help.

It turns out, what patient simply can’t realize how to use that cure properly, beacuse he didn’t read instruction for this drug till the end. Thus, instead of alleviate pains he just hamble themself and now want they money back! So, who is to blame?

Maybe projection isn’t all Logic.

Remarks

Looks like, I stripe this line and completely forgot what was intention for this post. Well, any code snippets and what I learned from Scala, partially from Clojure, Lisp and so one, will left for the next time (when I’ll have this time). I should split this.

Thoughts on Scala Type Inference

Alexander Pupeikis — Sat, 06 Aug 2011 19:25:34 +0000

There is no any images today, except maybe one. I particularly have a little brainstorming and maybe somebody would be interested too. Let’s try to scarcely touch the Scala type inference on small practical example.

In the Scala code snippets below I will provide a three methods with a short explanation in terms of the Scala type inference.

The first one is pretty straightforward, we’re defining some trivial logic and eventually Scala compiler (and interpreter, of course) will infer our return method type as Int, thus, there is no need to declare it explicitly. Here we go:

//-------------------------------------------------------------------------------------------
// 1. A simple one
//-------------------------------------------------------------------------------------------

def max2(x: Int, y: Int) = if (x > y) x else y

If we’ll define this method in the Scala interpreter and will make a call of the method by passing an Integer parameters, we’ll get something like this:

 scala> def max2(x: Int, y: Int) = if (x > y) x else y
 max2: (x: Int, y: Int)Int

 scala> max2(23,145)
 res0: Int = 145

Pretty easy. Our return type is Int, as mentioned above. By going further, the second method is simply a side effect of the method call and return type of the method always would be a Unit (a void in Java):

//-------------------------------------------------------------------------------------------
// 2. Side effect of the useless method call
//-------------------------------------------------------------------------------------------

def greet() = println("Hello, world!")

Declaring and running in the Scala interpreter:

 scala> def greet() = println("Hello, world!")
 greet: ()Unit

 scala> greet()
 Hello, world!

Hence, this method is pretty useless for us, but it shows how Scala compiler infers return types.

And the last one is an interesting thing… A type annotation must follow every function parameter, preceded by a colon, because the Scala compiler (and interpreter) does not infer function parameter types. A one interesting example initially was mentioned by Andrey Breslav (and maybe by somebody else, I don’t know), that makes a surprising revelation about Scala type inference. To not digress from a context and to be abridged, here is the example that deserve to think about:

//-------------------------------------------------------------------------------------------
// 3. Interesting
//-------------------------------------------------------------------------------------------

class InferTest {
    def foo_bar[T](x: T): T = x
    val b = foo_bar()
}

Just stopping by and try to think at this point. As already mentioned, Scala does not infer a function parameter types. Therefore, we’re trying to make a call without a parameter declaration and the question is: is this code will compile and if yes, then what is the type of ‘b’ ? Is it will be a Unit type, since we’re making a call of the method without a parameter (probably a Unit type) ? What do you think?

Your mind would be hamble fast as you’ll see a result. I’ll try to make it step by step. Firstly, let’s define a function in the Scala interpreter and make a method call with a String type:

 scala> def foo_bar[T](x: T): T = x
 foo_bar: [T](x: T)T

 scala> foo_bar("Wow cool!")
 res2: java.lang.String = Wow cool!

Secondly, let’s make the same, but by passing Integer type instead:

scala> foo_bar(9955)
res3: Int = 9955

Surprisingly very simple. A tension on both cortex hemispheres will grow up dramatically, when we’ll try to make a compulsive method call without a passing through any parameters. Ready?:

 scala> foo_bar()

 scala>

I was very astonished by seeing this result! It is even not a Unit type, it’s a type of nothing, a black hole. But, we can make a call.

Conclusion

As a corollary, you might see, that a confine of type safeness is slightly blurred for now and could even cause a sleep deprivation in some cases. Scala type safeness and complexity are still becoming to be a point of contention ever since. However, it does not mean, that you should expunge this wonderful language from your toolbox, instead you must to be aware of. I am wholeheartedly wish you not be trapped in such situations, but who knows…

Don’t know how are you, but me slightly suffering from a finger and mental fatigue at the end of this post. So, that’s enough for today!

IntelliJ IDEA on JRockit

Alexander Pupeikis — Thu, 26 May 2011 10:19:27 +0000

Not so long ago by following Henrik Stahl’s blog, I read this great news: JRockit is Now Free (and Other Java License Updates). Whoa! This is actually a great news! “But why?” you could possible ask me. Well, this is very good question and the answer is very simple – JRockit is a part of the Oracle Middleware, this is the most advanced, fast and powerful JVM on the planet Earth. Seriously, he is.

My personal experience by running IntelliJ IDEA with JRockit on Linux, I will try to cover here. However, JRockit also might be runnable on Windows systems and on ~~Sun~~ Oracle Solaris too. Nonetheless, I will not explain how to do that, because to get IntelliJ running on Solaris is a little bit tricky, involves some hacking (but possible) and time consuming. To get running this configuration on Windows is almost the same, just take a look at appropriate “bat” files and get rid unnecessary stuff. Everything is possible.

By the way, even on my old computer with Linux Kubuntu, IntelliJ is running on JRockit much faster and smoother, than on HotSpot based JVM. On my latest Toshiba laptop he is flying now, like a native application written on C/C++. Amazing experience.

Unfortunately, there is not possible currently to run JRockit on Mac OS X, albeit these two JVMs will be merged somehow in future and would be available through Oracle JDK and Open JDK. At least client version would be available on Mac OS X, or I so believe. Eventually, just await a little bit.

The official Oracle press release about JDK Roadmap for Advancing JavaSE you may find here and Oracle’s JVM Strategy.

Getting Started.

First of all, we should download the Oracle JRockit JDK 28.1.3 and install it somewhere in our system (Home or System directory. It doesn’t make any sense). Next what we should to do – is configure IntelliJ IDEA startup script, because IntelliJ will not automatically found and use JRockit. We need directly makes it possible. So, navigating to our IntelliJ installation directory and opening file with name idea.sh in ‘IntelliJ IDEA install dir’/bin/. Then, specifying the location of the JDK installation directly:

# For clarity reason we providing a full path here.
# You can make a simlink to the JRockit JDK like: IDEA_JDK="/usr/java/"
IDEA_JDK="/home/apupeikis/bin/jrockit-jdk1.6.0_24-R28.1.3-4.0.1/"

# Clarify JDK location before this line
if [ -z "$IDEA_JDK" ]; then
    IDEA_JDK=$JDK_HOME

...
# For brevity reason

After we made our changes starting IntelliJ, waiting a little and getting that friendly message:

 apupeikis@Wunderwaffen:~$ /home/apupeikis/bin/JetBrains/IntelliJ\ IDEA/bin/idea.sh

 [WARN ][jrockit] MaxPermSize=250m ignored: Not a valid option for JRockit
 Unknown option or illegal argument: -XX:ReservedCodeCacheSize=64m.
 Please check for incorrect spelling or review documentation of startup options.

 Could not create the Java virtual machine.

Well, what’s next and ~~what are hell is going on here?!~~ what is going wrong here exactly?!

Previous message in console are self explanatory. JVM flags – -XX:MaxPermSize and -XX:ReservedCodeCacheSize is are HotSpot JVM flags and they do not supported in JRockit JVM. In HotSpot JVM this is are PermGen handling flags, that is necessary, otherwise you will suffer from PermGen exceptions every time:

 [info] Error occurred during initialization of VM
 [info] Could not reserve enough space for object heap
 [395 javajni.c] [error] CreateJavaVM Failed

At the same time Oracle’s JRockit JVM not suffering from such troubles and its PermGen allocation can be Gigs in size. You can increase the PermGen size with HotSpot, but that it’s not a problem primarily due to memory leaks. PermGen space gets eaten up aggressively by applications which implement heavy use of Reflection like IDEs. As an another typical example, if you have a Spring/Hibernate application running in Tomcat, be prepared to bump that PermGen space up a lot. Alternatively, you can switch to JRockit which handling PermGen differently than ~~Sun’s~~ HotSpot based JVM. It generally has better performance as well. This is exactly that we’re trying to do!

To solve the problem, open the file idea.vmoptions in ‘IntelliJ IDEA install dir’/bin/ and delete or comment these two flags:

-XX:MaxPermSize=250m
-XX:ReservedCodeCacheSize=64m

That’s it! Run IntelliJ IDEA again and notice – he will bring faster and run much smoother. Eventually, we’ve got the most intelligent Java IDE running on the most advanced JVM – beautiful tandem, isn’t it? Enjoy.

More Information

To get rid any blind luck by running new JVM, that you’re not familiar with, check out the JRockit Command-Line Reference.

And of course, to know more about Oracle’s JRockit JVM, Mission Control (that is packed with JVM), other features and how most of the JVMs actually works, I suggest you to check out the book – Oracle JRockit: The Definitive Guide by Marcus Lagergren and Marcus Hirt (on Amazon and on Packt). So, enjoy these new features, capabilities and upcoming JDK 7 release this summer!

Multi-threaded painting on the Canvas?

Alexander Pupeikis — Tue, 10 May 2011 08:37:22 +0000

Like in Java Swing applications, in Android apps everything is happening, when the system creates a thread of execution for the application, named genuinely “main thread”. Also, this thread is very important, because it’s in charge of dispatching events to the appropriate user interface widgets (like clicks and touches), including drawing events (exactly what we are looking for). It is also a thread in which your application interacts with components from the Android UI toolkit. When your application performing some intensive work, this single thread can yield poor performance (and be sure, it will happen), if you’re not properly handling such tasks. From the user’s perspective, the application appears to hang. Even worse, if the UI thread is blocked for more than a few seconds (about 5 seconds currently) a user is presented with the infamous “application not responding” (ANR) message dialog. So sad…

Apparently, user will uninstall your application and fill out the comment field in Android Market with something like this –> ~~this app is a Bullshit I ever seen! What a crock!~~ the application just hung when I pressed a download button! Will not recommend to anybody to install it.

The clue is one – the Andoid UI toolkit is not thread-safe. To be honest, you must not manipulate your UI from a non UI (main) thread – instead, you must do all manipulations with user interfaces from the UI thread only! Therefore, there are simply two rules for Android single thread model:

Do not block the UI thread;
Do not access the Android UI toolkit from outside the UI thread;
~~Do not drink a beer when you developing your apps and do not believe in miracles.~~

So, to abandon these slightly uncomfortable situations we will do somethings like…

Worker Threads. What about Canvas, I asking you?!

Nothing about shiny and glossy Canvas here due to big boring of the section.

Every of your intensive and long running operations should to be performed outside of the UI thread, not pausing user interfaces, not blocking it and let users just to be happy. Thus, if you have any operations that are not instantaneous, every such operations must be performed on a “background” or “worker” threads. This is a vital to success.

As an example, below is a sample code to perform some of such operations. We downloading an image from external resource and displaying it in ImageView:

private ImageView imageView;
// ...

public void onDoingSomething() {
    new Thread(new Runnable() {
        public void run() {
            final Bitmap b = loadImageFromOutside("http://mycloud.com/image.png");
            imageView.setImageBitmap(b);
        }
    }).start();
}

Well, something went wrong here… This code possible will block your application’s UI thread someday. But, what exactly is wrong here?

Everything seems to be fine and looks like so. However, this code violates the second rule of the single-threaded model: do not access the Android UI toolkit from outside the UI thread — this sample modifies the ImageView from the worker thread, instead of the UI thread. This is not only breaks the rules, although we think it’s just a bug, but it makes users very unhappy and generates absolutely free and disruptive ads for our application. Anybody will regret about spent time and this is only the last part of a trouble. As a worst things, what possibly might happen – you will cripple user’s data in a various ways and then user will hate you! I guarantee it to you!

The short fix is to deal with UI thread properly. Next methods would be unbelievably helpful:

Knowledge of these methods will help you a lot and possibly save some time. How to fix the code above? Simple:

private ImageView imageView;
// ...

public void onDoingSomethingGood() {
    new Thread(new Runnable() {
        public void run() {
            final Bitmap bitmap = loadImageFromOutside("http://mycloud.com/image.png");
            imageView.post(new Runnable() {
                public void run() {
                    imageView.setImageBitmap(bitmap);
                }
            });
        }
    }).start();
}

Now it implemented how it should be and everybody happy.

Slightly funny usage of AsyncTask. Still no Canvas here?

Unfortunately, no Canvas and here. I told you!

Perhaps, the best solution is to extend AsyncTask class, which allows you to perform asynchronous tasks on your beautifully designed user interface. It performs the blocking operations in a worker thread and then publishes the results on the UI thread, without requiring you to handle threads and/or handlers yourself. By the way, if you familiar with Java Swing you may notice, that AsyncTask class are very similar to SwingWorker class with a small modifications. There is another class, that should to be consider to use in your worker thread, to process messages delivered form the UI thread. And here it is – a Handler! Nonetheless, please, read these boring materials by yourself. We are going to the funny sections…

Painting on the Canvas. Trying to make this Multi-threaded.

What is a Canvas? Canvas is a layer or abstraction layer, that is used to draw an Android View and possibly to draw your own custom graphics.

Why I should use Canvas? Well, here is possible answers on this very good question:

To build custom components or your own implementation of the existing Views by extending one. Some info on DevGuide too. Satisfaction not guaranteed, though;
To paint some custom graphics on the existing components, through state changes of this component (possibly an overlay);
To paint an Overlay on the MapView;
Direct pixels painting like in Game development;
To do something incredibly interesting, that I still don’t know about. So, let me know about these very exciting ideas, that I didn’t heard of, yet!

Are you concerned now? In most cases you just should overwrite the onDraw() method and implement any drawing code here. Besides the basic approach, take a look at “build custom components” manuals and other documentation or books, that you will find interesting to yourself. I don’t know any of them in Android way…

As a possible option to draw on Canvas in Multi-Threaded way is – to extend SurfaceView class, implement SurfaceHolder.Callback class’ callback methods and create your custom thread to deal with glossy Canvas. Simple, isn’t it?

I am so tired from your stupid ramblings! Just show me the code!!!

You right, no more ramblings… here is the code:

import android.content.Context;
import android.graphics.Canvas;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

public class SurfaceViewCanvas extends SurfaceView
                     implements SurfaceHolder.Callback {
    private SurfaceHolder holder;
    private SurfaceViewThread surfaceViewThread;
    private boolean hasSurface;

    SurfaceViewCanvas(Context context) {
        super(context);
        init();
    }

    // Implementing all callback methods below
    public void resume() {
        // Create and start the graphics update thread
        if (surfaceViewThread == null) {
            surfaceViewThread = new SurfaceViewThread();
            if (hasSurface)
                surfaceViewThread.start();
        }
    }

    public void pause() {
        // Stop the graphics update thread
        if (surfaceViewThread != null) {
            surfaceViewThread.requestExitAndWait();
            surfaceViewThread = null;
        }
    }

    public void surfaceCreated(SurfaceHolder holder) {
        hasSurface = true;

        if (surfaceViewThread != null)
            surfaceViewThread.start();
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        hasSurface = false;
        pause();
    }

    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
        if (surfaceViewThread != null)
            surfaceViewThread.onWindowResize(w, h);
    }

    private void init() {
        // Create a new SurfaceHolder and assign this class as its callback
        holder = getHolder();
        holder.addCallback(this);
        hasSurface = false;
    }

    private final class SurfaceViewThread extends Thread {
        private boolean done;

        SurfaceViewThread() {
            super();
            done = false;
        }

        @Override
        public void run() {
            SurfaceHolder surfaceHolder = holder;

            // Repeat the drawing loop until the thread is stopped
            while (!done) {
                // Lock the surface and return the canvas to draw onto
                Canvas canvas = surfaceHolder.lockCanvas();

                // TODO: Perform some Draws on the Canvas. Whatever you want!
                // Unlock the canvas and render the result
                surfaceHolder.unlockCanvasAndPost(canvas);
            }
        }

        public void requestExitAndWait() {
            // Mark this thread as complete and wait it to finish himself
            done = true;
            try {
                join();
            } catch (InterruptedException ignored) {
            }
        }

        public void onWindowResize(int w, int h) {
            // Deal with a change in the new surface size
        }
    }
}

That’s it!

Own Git repository with modern Web View

Alexander Pupeikis — Wed, 02 Mar 2011 15:24:43 +0000

Let us suppose: we need our own private Git repository running on our remote server. It might be our own hardware in our own office, servers room or it can be a Virtual Private Server(s) running on side of our hosting provider, Cloud Servers or whatever you want. That even could be a dedicated or shared hosting, it doesn’t sucks! No matter, what Server(s) (except one simple and intuitive rule: NO Windows inside! It sucks!) or hosting provider we use, a task is still the same: our own private Git repository. As an additional feature, we want to run with some modern Git Web View. The first question here – why just not use GitHub as a service for our private and public repositories?! Possible answer here – I’m particularly using GitHub for public repositories, however, what if we want to have an unlimited number of collaborators and repositories??!! From this point look at the GitHub pricing now. Maybe we just do NOT want to pay for our private repositories and also, want to keep it in top secret. Yes, I’m a paranoid.

Technology Stack

A brief overview of what we’ll use in this installation:

Obviously a Git;
Gitosis – for access control to our repositories;
Connection through SSH. In many cases OpenSSH software on the server end. It should to be installed already. If not, do it yourself (if, for some mysterious reasons, you don’t know how to do that – do NOT ask me how and stop reading this). I’ll not explain how to configure authentication with WebDav here – Google it!;
For the Git Web View we will use Warehouse 2, that is actually a complete rewrite of original Warehouse for SVN that is build for Git;
Ruby and Ruby on Rails. If you’re running under shared hosting and of course, have not root access, check out if your provider supports Ruby and Rails installed on your server. If not, this is sad, because in such case you can install Ruby into user’s home directory, however, Rails installation will be very difficult or even impossible, because you’ll need at least Passenger installed and configured. Whatsoever, in many cases you will notice availability of Ruby on your server. But, if you’re using sharing hosting plan and hosting provider do NOT providing Rails support, I cannot help you. Pick another provider instead or switch to the Virtual Private Server(s), Cloud Sever(s), whatever;
The Python 2.5 and Python setuptools package.

That’s all what we need. Although, none of these steps are difficult, the number of steps themself, can be intimidating. Don’t let it get to you. If you make a mistake, wipe it clean and start over. Okay, lets go!

Git with Gitosis

Git by itself, out of the box, provides no method of access control. If you know URL for a git repository, you can clone it. Without some mechanism of access control, you can commit to it as well. Gitosis is a wrapper that provides fine grained access control to your publicly visible git repositories.

You can configure Gitosis such that each user has different authentication and authorization levels for each repository in the set of repositories contained in the directories of a user account.

As first step, create a user account, in this example githuber, with shell access. This account will be used for the git repositories and nothing else. Note, that after successfully installing Gitosis, you will NOT be able to login to this account. You can login to a different user account and su to this account if you need shell access.

If you are not already using SSH generated public and private keys, you will need to have SSH on your desktop computer. After installing SSH, you will need to generate the public/private key pair. Well, you need to get your desktop user public ssh key onto the remote server:

1 2	[local]$ ssh-keygen -t rsa [local]$ scp ~/.ssh/id_rsa.pub githuber@example.com:~

If you already have a public/private key pair, then the first command will let you know and don’t bother over-writing it. NOTE: do NOT add your RSA public key to the Gitosis user’s .ssh/authorized_keys. If you do this, you can still access this new account after installation, but Gitosis will not able to let you push new repository, and you need to type full path when cloning gitosis-admin.conf later. Instead, use password to login this new account.

Installing Git

Many hosting providers have Git already installed. Of course, a more recent release is suggested. However, if your server indicates its running 1.7, so just skip this step. Check out your Git version like this:

 [server]$ which git
 /usr/bin/git
 [server]$ git --version
 git version 1.7.1

If there is no Git installed or version on your server 1.6 (or even less), then install Git following by these steps:

 [server]$ cd
 [server]$ mkdir src; cd src
 [server]$ wget http://kernel.org/pub/software/scm/git/git-1.7.4.tar.gz
 [server]$ tar xzf git-1.7.4.tar.gz
 [server]$ cd git-1.7.4
 [server]$ ./configure -prefix=$HOME NO_MMAP=1
 [server]$ make && make install

These steps will install Git into your home directory. Hence, if you have root access, install Git into the system instead, with appropriate changes to the commands above (use sudo or type almost the same being a super user). Also note: we’re using compilation flag NO_MMAP=1 only from installation into user’s home directory to prevent procwatch service to kill your Git daemon. Since Git while pushing process unpacking an objects and accommodating a lot of space, procwatch service may kill Git daemon without an error and you will not understand why. It’s very hard to catch. Just use this flag with installation as a non-privileged user.

For more information about Git configuration look at this.

Installing Python

Gitosis requires Python at version 2.4 or higher. If your server reports an appropriate version of Python, so again skip this step. If you’re unlucky in this way just follow steps below to install Python into user’s home directory (for super user just change commands as appropriate):

 [server]$ cd ~/src
 [server]$ wget http://www.python.org/ftp/python/2.5.5/Python-2.5.5.tgz
 [server]$ tar xzf Python-2.5.5.tgz
 [server]$ cd Python-2.5.5
 [server]$ ./configure --prefix=$HOME
 [server]$ make && make install

Installing Python Install Tools

Gitosis is implemented in python and is packaged as a python package. The python install tools are required to install Gitosis. You need the install tools matching the release of python you are using.

 [server]$ mkdir -p $HOME/lib/python2.5/site-packages
 [server]$ export PYTHONPATH=$HOME/lib/python2.5/site-packages
 [server]$ cd ~/src
 [server]$ wget http://pypi.python.org/packages/2.5/s/setuptools/setuptools-0.6c11-py2.5.egg
 [server]$ sh setuptools-0.6c11-py2.5.egg --prefix=$HOME

Installing Gitosis

You will clone the Gitosis repository and install from that repository. Also, you will set some persistent environment variables on your user account, that will cause the correct instances of git and python to be invoked.

 [server]$ git clone git://eagain.net/gitosis.git
 [server]$ cd ~/src/gitosis/; export PATH=$HOME/bin:$PATH
 [server]$ python setup.py install --prefix=$HOME; cd
 [server]$ echo "export PYTHONPATH=$HOME/lib/python2.5/site-packages/" >> .bashrc
 [server]$ echo "export PYTHONPATH=$HOME/lib/python2.5/site-packages/" >> .bash_profile
 [server]$ echo "export PATH=$HOME/bin:$PATH" >> .bashrc
 [server]$ echo "export PATH=$HOME/bin:$PATH" >> .bash_profile
 [server]$ . ~/.bash_profile; gitosis-init < id_rsa.pub
 [server]$ chmod 750 $HOME/repositories/gitosis-admin.git/hooks/post-update

Don’t ask. It’s magic.

Using Gitosis

Administering Gitosis uses Gitosis itself. Your public key gives you access to a repository called gitosis-admin.git. The gitosis-admin.git repository was created when you initialized Gitosis in the previous step. To get access to this repository and its files, you will clone that repository from your server user account to your desktop computer.

1
2
3

 [local]$ mkdir ~/projects; cd ~/projects
 [local]$ git clone githuber@example.com:gitosis-admin.git
 [local]$ cd gitosis-admin

NOTE: IF the above didn’t work for you, you have to change the ‘git clone …‘ line to:

1	[local]$ git clone githuber@example.com:~/repositories/gitosis-admin.git

You now have the Gitosis configuration files on your desktop computer. Using these files you will add users and repositories to your remote host repositories.

Adding a Repository and (optional) User

To add a repository to your remote host, edit the gitosis.conf file in the gitosis-admin repository. After adding the repository to the Gitosis controls, you will create the repository and push it to the remote host.

 [local]$ cat ~/projects/gitosis-admin/gitosis.conf
 [gitosis]

 [repo JavaPixelazier]
 description = The stub of sample applications with primary goal on Java Desktop
 owner = alex@apleben.com

 [group devs]
 members = alex@apleben.com

 [group admins]
 members = alex@apleben.com

 [group gitosis-admin]
 writable = gitosis-admin
 members = @admins

 [group myteam]
 writable = JavaPixelazier
 members = @devs

Where:

myteam: is the name of a group (not the repository);
JavaPixelazier: is the name of the new repository;
members : is a space delimited list of users who can commit to this project (SSH public key identification).

When you are adding new users, you will have to copy their public key into the directory ~/projects/gitosis-admin/keydir. Follow the admonitions about spurious newline characters in SSH public keys. Push the gitosis-admin repository back to the remote host:

1 2	[local]$ git commit -a -m"Add repository: JavaPixelazier, writable by Alex" [local]$ git push

Now create the project on your local desktop…

 [local]$ cd ~/projects # or where ever you keep stuff
 [local]$ mkdir JavaPixelazier; cd JavaPixelazier
 [local]$ git init
 [local]$ git remote add origin githuber@example.com:JavaPixelazier.git
 # do some work, git add and commit files
 [local]$ git push origin master:refs/heads/master

Subsequent push to the remote repository does NOT require anything more than just “push”. Your repository is now on your account at remote server!

We left all hard work behind. The last step is easy and not so challenged.

Git with Warehouse

The last step is – Warehouse installation, configuration (that doesn’t hurts) and synchronization with your Git repositories. As mentioned previously, Warehouse requires Ruby and Ruby on Rails installed on our Server. If and only if, you’re sharing hosting customer, whose very unlucky to do not have Rails or even Ruby installed on your particular server, thats it – end of the game for you. It is very hard or even not possible to install Rails in such situation, because you need at least Passenger installed and configured on the server. The answer here could be only one – re-think your Hosting Provider. If you’re the lucky one with Rails already installed, I’ll explain only one thing here: how to properly configure locally installed Gems for usage. This is usable in situation there you have not root access, otherwise install Gems into the system instead. Nonetheless, if you have root access and don’t know how to install Ruby and Rails – the Search Engine is your best friend ever.

Using Gems Installed in Your Home Directory

You may install gems which is not pre-installed on the servers in your home directory. Assuming you use bash, do the following:

 [server]$ mkdir ~/.gems
 [server]$ cat >> ~/.bash_profile
 export GEM_HOME=$HOME/.gems
 export GEM_PATH=$GEM_HOME:/usr/lib/ruby/gems/1.8

Then press CTRL+D to exit cat and return to the command prompt. You may then install gems in the usual way (e.g. gem install gem_name). The .bash_profile method above resulted in the following error: Could not find RubyGem sources (> 0.0.0) when I tried installing a gem, but the instructions on altering your .gemrc file below worked perfectly. HOWEVER, without altering the .bash_profile rake kept complaining about not seeing my locally installed gems even when I passed it GEM_HOME and GEM_PATH manually. So, you may need both.

An alternative to setting the GEM_PATH environment is to create a ~/.gemrc file with the following contents:

 gemhome: /home//.gems
 gempath:
 - /home//.gems
 - /usr/lib/ruby/gems/1.8

Installing Warehouse in Production

Installation for production use is almost the same like for the development environment. Be aware, that domain has been configured with Passenger or Mongrell support (FastCGI is strongly NOT recommended).

If you’re running Warehouse on your server under some domain, first go inside the directory, where application will be installed. In most cases directory will have the name of the domain:

1	[server]$ cd ~/subdomain.yourdomain.com/

Then, clone the project:

1
2
3

 [server]$ git clone git://github.com/drcapulet/warehouse.git
 [server]$ mv warehouse/* ~/subdomain.yourdomain.com/
 [server]$ rm -rf warehouse

Install dependencies:

1	[server]$ gem install bundler && bundle install

Check out if you have the Pygments library installed. This library are necessary for source code highlighting.
In production you probably do not want to use sqlite, instead MySQL is preferable. To use MySQL type this inside the RAILS_ROOT directory:

1 2	[server]$ rm config/database.yml [server]$ cp config/database.mysql_sample.yml config/database.yml

Then, make sure you have the database created and loaded in the schema. Again, from the RAILS_ROOT directory:

1	[server]$ RAILS_ENV=production rake db:schema:load

Before starting the server make sure you properly configured your domain name in the RAILS_ROOT/config/warehouse.yml, otherwise application just will not start.
Find the section and configure it properly:

1 2	production: host: http://subdomain.yourdomain.com/

Add in a new repository, and run:

1	[server]$ RAILS_ENV=production rake warehouse:sync

Apparently, you’ll cause an exception with the repository sync error. Don’t worry, start the server and go to your domain in the browser window. Register new user, login and add new repository, where path to the repository will be something like this: /home/USERNAME/repositories/super_secret_project. After that, go back to the console prompt and type:

1	[server]$ RAILS_ENV=production rake warehouse:sync[/home/USERNAME/repositories/super_secret_project]

Your initial repository should to be synchronized properly now. Login to warehouse and enjoy!

Conclusion

After all these steps you will have an ability to create your own private Git repositories with authorization controlled by Gitosis and modern Git Web View provided by Warehouse for Git to us. Maybe this short article will be helpful for somebody else, build by my own experience on it. Also, take a look at some screenshots below

Machine Learning Notes

Alexander Pupeikis — Mon, 14 Feb 2011 10:03:48 +0000

Since I’ve found a couple (actually not a couple) of interesting resources, completely related to the Machine Learning courses and books, I need to remember a lot of these points. It is very helpful for myself, because when I was studied in the University, there is either not been something related to this theme, nor our professors covered these thing with us. So sad to spend many times by studying “new technology”, those in nowadays has no particular sense at all. Prematurely, this is pointed for me, however, if it will be helpful to some one else – well, you’ll gotcha

The Machine Learning materials are related to Artificial Intelligence, Neural Networks, Neural Informatics as a kind of stuff. I have no idea how to sort these materials, but prematurely to me, I’ll just put it into three category: courses, books and related open source libraries. Whatsoever, what is preferable to another folks, I don’t care, because it couldn’t possible to imagine. If for one man visual contact is much preferable than others – books is your’s. If for another man audio contact is preferable, then obviously, the audio course would help such human a lot, than any of the books. However, nonetheless what kind of contact is preferable for two absolutely distinct peoples, the video course is much and much preferable for everybody. There is no reason to explain it and since this is my note – think I am right.

Well, will try to put all of these link together here. Again, I have no idea how to sort it, just pick a volatility manner in every category. First, the Machine Learning courses:

Finished with courses, going further to the books side. All of the books on English, obviously. The sequence doesn’t matter here, only things matter:

Introduction to Machine Learning, Second Edition (Adaptive Computation and Machine Learning). The MIT Press; 2 edition (February 26, 2010);
Data Mining: Practical Machine Learning Tools and Techniques, Third Edition. Morgan Kaufmann; 3 edition (January 20, 2011);
Clever Algorithms: Nature-Inspired Programming Recipes. LuLu; 1st edition (January 31, 2011);
Information Theory, Inference & Learning Algorithms. Cambridge University Press; 1st edition (June 15, 2002);
Machine Learning. McGraw Hill Higher Education; 1st edition (October 1, 1997);
Pattern Classification (2nd Edition). Wiley-Interscience; 2 edition (October 2000);
Neural Networks for Pattern Recognition. Oxford University Press, USA; 1 edition (January 18, 1996);
Pattern Recognition and Machine Learning (Information Science and Statistics). Springer; 1st ed. 2006. Corr. 2nd printing edition (October 1, 2007).

And the last point to cover is the AI related libraries and software. Didn’t found a lot of entries here, but….. here they are:

People do not tinkering enough, sometimes copying, sometimes just stealing as a good or great actors, developing stupid and totally useless software, toys like new mobile OS or new beautiful UI, called Look and Feel. We’re not concerned about tomorrow, only looking at yesterday, thought about profitable deal and what we’re loosed, what reached. People actually, only cares about his own ass and not about somebody else, elsewhere or else-how. Almost everybody wish to be a successful famous person with a billion dollars on his bank account. But why?! Is all these money will help you to prevent your death? Of course not. But, why are we still collecting these stupid papers and our stupid deals? Because we all a monkeys, just a monkeys in the big circus called Planet Earth. We are not so smart as it may look at the first observation. Everything is distinguished in the comparison.

Theoretically, more and more money could be invested into a science, AI, Neural Networks/Informatics investigation, health insurance and investigation, rather than buy a new stupid sports car, lands on the moon and so forth. Currently, only a six, a SIX peoples are working on the Expedition 26 space program. NASA’s Space Shuttle Program Concluded. The successful and very expensive Russian Buran Space Program has been concluded. What a hell are we doing?! Yeah, I forget…. we just a monkeys in the big circus. We still cannot reach another planets to investigate his atmosphere, build a colony, find an evidence of new forms of live…. we can’t for many reasons. One of the reasons – we’re very addictive to our atmosphere and environment and cannot leave our place cheaply. However, Artificial form of live can do this for us.

From my personal point of view: to be a successful human means to do something tremendous not only for yourself, doesn’t matter how are you doing these, only matter to be successful in your deal. I am reached end of the note.

Custom Android View: the definition

Alexander Pupeikis — Sun, 23 Jan 2011 09:44:42 +0000

The first question, that is rotating in my head is: why I should implement my own custom View and just not to use one of the standard View’s? Actually, there is not a problem. Most of the Android applications using standard View’s, LayoutGroup’s, only customizing its color schemes, Layout and another general based stuff, applied to every day Android development. So, how I can explain my or maybe your interest on customization? I’m very meticulous in choices, laboriously deciding what to do, what not and what to choose from. Here is my short opinion on these question:

Intension on user experience: component (or View) are not presented in standard Android outlet;
Polish application with your own idea of view;
Enrich the standard View’s: improve quality, enhance with new capabilities;
You want your application looks the same on any mobile platforms;
What ever you want, just put here, in place of your own wishes.

Do not want either to compare Android user experience and View’s with iPhone, nor discriminate one of these wonderful devices, although must slightly touch a difference between them. Really, should.

Android Standard UI Elements Are… Not Sexy

Attention please: I have to admit, I’ve been trying to write this post without enjoying a beer!

As a developers and designers we are trying to create the best quality application, for best user experience. Sometimes, our attempts are fail by lacking features in the language, ~~in the frameworks,~~ in the platform. Hence, to fill these missing we are spending more time to do something, to fill the lack through the magic incantations. In many cases, it just works fine for everyone. Well, loosely speaking, visual comparison is the best way to realize the difference among them. Two applications – two platforms (and two absolutely different languages, different patterns). I’ve been selected the DailyBooth application for these purposes. You could choose your own. iPhone version comes first:

Android goes next:

Can somebody spot the differentiation?

Implementation

To implement our own View, first we need create a new class, those will extend the Android View class. As the next step, we need to implement the constructors of our newly created View:

One constructor required for in-code creation of our View;
The second one is required for inflation from resource file.

Also, we should override

1	protected void onMeasure(int wMeasureSpec, int hMeasureSpec) { }

to properly inflate the View and make a call for

1	setMeasuredDimension(measuredHeight, measuredWidth);

to set the dimension of our View. Otherwise, we will issue a runtime exception when the controls is laid out. To get a measured height and width we also should implement two additional methods, those will calculate the ideal size of the control:

1 2	private int measureHeight(int measureSpec) { } private int measureWidth(int measureSpec) { }

These two methods will operate with parameters pushed into onMeasure() to calculate size of the control. Inflation of the control is only a part of the job. We wish that our View will be sexy, polish and amazing! To do that, we should override

1	protected void onDraw(Canvas canvas) { }

and perform anything we want here through the canvas.

And ones more… Achtung!!! For efficiency reasons NEVER create your Paint instances in the onDraw(Canvas canvas) { } , this should to be done in the constructor! The same is applicable to any other reusable objects: creation should be done in the constructor!

The skeleton code of the custom View is presented below:

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;

public class MyView extends View {
    private Paint mTextPaint;

    // Constructor required for in-code creation
    public MyView(Context context) {
        super(context);
        initBrushes();
    }

    //Constructor required for inflation from resource file
    public MyView(Context context, AttributeSet attrs) {
        super(context, attrs);
        initBrushes();
    }

    // Constructor required for inflation from resource file
    public MyView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        initBrushes();
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent keyEvent) {
        // Return true if the event was handled.
        return true;
    }

    @Override
    public boolean onKeyUp(int keyCode, KeyEvent keyEvent) {
        // Return true if the event was handled.
        return true;
    }

    @Override
    public boolean onTrackballEvent(MotionEvent event) {
        // Get the type of action this event represents
        int actionPerformed = event.getAction();
        // Return true if the event was handled.
        return true;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // Get the type of action this event represents
        int actionPerformed = event.getAction();
        // Return true if the event was handled.
        return true;
    }

    @Override
    protected void onMeasure(int wMeasureSpec, int hMeasureSpec) {
        int measuredHeight = measureHeight(hMeasureSpec);
        int measuredWidth = measureWidth(wMeasureSpec);
        // MUST make this call to setMeasuredDimension
        // or you will cause a runtime exception when
        // the control is laid out.
        setMeasuredDimension(measuredHeight, measuredWidth);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        // Get the size of the control based on the last call to onMeasure.
        int height = getMeasuredHeight();
        int width = getMeasuredWidth();
        // Find the center
        int px = width / 2;
        int py = height / 2;

        mTextPaint.setColor(Color.WHITE);
        // Define the string.
        String displayText = "My custom View!";
        // Measure the width of the text string.
        float textWidth = mTextPaint.measureText(displayText);
        // Draw the text string in the center of the control.
        canvas.drawText(displayText, px - textWidth / 2, py, mTextPaint);
    }

    private void initBrushes() {
        // Create the new paint brushes.
        // NOTE: For efficiency this should be done in
        // the views' constructor
        mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);

        // Create any other reusable objects here
    }

    private int measureHeight(int measureSpec) {
        int specMode = MeasureSpec.getMode(measureSpec);
        int specSize = MeasureSpec.getSize(measureSpec);
        // Default size if no limits are specified.
        int result = 500;

        if (specMode == MeasureSpec.AT_MOST) {
            // Calculate the ideal size of your
            // control within this maximum size.
            // If your control fills the available
            // space return the outer bound.
            result = specSize;
        } else if (specMode == MeasureSpec.EXACTLY) {
            // If your control can fit within these bounds return that value.
            result = specSize;
        }
        return result;
    }

    private int measureWidth(int measureSpec) {
        int specMode = MeasureSpec.getMode(measureSpec);
        int specSize = MeasureSpec.getSize(measureSpec);
        // Default size if no limits are specified.
        int result = 500;

        if (specMode == MeasureSpec.AT_MOST) {
            // Calculate the ideal size of your control
            // within this maximum size.
            // If your control fills the available space
            // return the outer bound.
            result = specSize;
        } else if (specMode == MeasureSpec.EXACTLY) {
            // If your control can fit within these bounds return that value.
            result = specSize;
        }
        return result;
    }
}

Nonetheless, we could extend not only the View class, also we can do the same by extending an existing controls, like Button, TextView and so one.

Encrypting your class files

Alexander Pupeikis — Sun, 19 Dec 2010 20:46:54 +0000

A couple of months ago I was thought about one feature: how to cipher my class files? And this post I will put into this way. In any case, why you should worry about that? Why you need to encrypt and then decrypt your class files back? Of course, you should not worry about that if your project is completely Open Source, therefore your code is open to everyone. But you should worry about protection of the code if your project, obviously, a proprietary software and you want to keep it closed against any attempts to crack it. Whenever you are inventor of the revolutionary idea or just want to promote a paid version of the software, you should worry about protection of your code against to be stolen.

The first to keep in mind is: your algorithm should to be unique! I will try to show you how to implement a simplest version of it. Any sophistications need to be your own.

The math approach and the model

I never talking about that (because it is mean to be a programmer), but here I come…. you should not scary the mathematics, this is your friend. And don’t give up, never! If the mathematics terminology is associated only with your grumpy teacher and that’s it, I cannot help you. Reconstruct yourself and your mind too.

Okay, lets go into the math model and what to start from. First, behind the all math model we will use a pair of the keys: public key and private key. The private key you should keep safely. In our demo we will hard code the private key into the tool and let to user choose his own public key. Also, I think the private key need to be long enough. The private key for our demo is:

1
2
3

// the private key.

private static final String privateKey = "Rechtsschutzversicherungsgesellschaften";

For the encryption process purposes we will use custom algorithm to cipher the class files. You may choose your own or just use one of the standard algorithm like RSA, AES and so fourth. In the encryptProcessing() method we are instantiating the EasyCipher class instance with our hard coded private key (do you remember it?):

private static void encryptProcessing() {

// creating easy cipher with the private key
EasyCipher cipher = new EasyCipher(privateKey);

//...
}

As the next step, we are generating the secret and unique pass phrase with a public key provided by the user. Also, we are parsing our string pass phrase to the integer key, those will be used in the actual byte shifting:

private static void encryptProcessing() {
//...
// generating the secret pass phrase with a public key
final String passPhrase = cipher.encrypt(publicKey);
final int key = parseString(passPhrase);

//...
}

After we are obtained our unique key, we can now go throughout the directory with class files, that need to be ciphered! What we will gone do with this obtained key? Okay, this is where magic comes true…. We will fetch the directory with class files, construct out file with “.pinpuk” suffixes instead of “.class” (pretty funny, eah?), will read the bytes of each class file and add to each byte our unique key obtained previously, write each byte to the output file with “.pinpuk” suffix. Here is the code outline:

try {
            // Loads all class files found in the directory "inputDir"
            File classDir = new File(inputDir);
            FileTreeWalker walker = new FileTreeWalker(classDir,
                    new UnixGlobFileFilter("*.class"));
            walker.walk(new FileTreeWalk() {
                @Override
                public void walk(File path) throws IOException {
                    FileInputStream in = null;
                    FileOutputStream out = null;
                    FileChannel channel = null;
                    try {
                        // constructing an out file with ".pinpuk" suffixes instead of ".class"
                        String outFileName = path.getName().substring(0,
                                         path.getName().lastIndexOf('.')) + ".pinpuk";
                        String outFile = path.getParent() + "/" + outFileName;

                        in = new FileInputStream(path);
                        out = new FileOutputStream(outFile);
                        channel = in.getChannel();

                        int length = (int) channel.size();
                        MappedByteBuffer buffer = channel.map(
                                         FileChannel.MapMode.READ_ONLY, 0, length);

                        for (int p = 0; p < length; p++) {
                            int ch = buffer.get(p);
                            byte c = (byte) (ch + key);
                            out.write(c);
                        }
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        if (channel != null) {
                            channel.close();
                        }
                        if (in != null) {
                            in.close();
                        }
                        if (out != null) {
                            out.close();
                        }
                    }
                }
            });

        } catch (IOException exception) {
            exception.printStackTrace();
        }
    }

However, I forgot to mention and explain the EasyCipher. He takes only two methods:

public String encrypt(final String text) {};

public String decrypt(final String text) {};

One of the methods encrypt and another one decrypt provided string with our custom algorithm (there your implementation go). I will show here only one implementation – of the encryption method. The whole source code you could find in the end of this post (do not want to read it? Drop it and fetch the code):

public String encrypt(final String text) {
long finalKey = 0;

for (int i = 0; i < key.length(); i++) {
      long tmpKey = key.charAt(i);
      tmpKey *= 128;
      finalKey += tmpKey;
}

Random generator = new Random(finalKey);
String result = "";

for (int i = 0; i < text.length(); i++) {
      int temp = (int) text.charAt(i);
      temp += generator.nextInt(95);
      if (temp > 126) temp -= 95;
      result += (char) temp;
}
return result;
}

Pretty easy, right? This is there the mathematic is our best friend ever.

As the last words here, I need to explain how to use the tool to encrypt your own class files:

Run the CryptoClassTool. This is the gui based utility;
Chose the directory with your class files (probably, select one of the files) or provide it directly;
Enter your public key;
Push an appropriate button to start;
Get the Success message.

Loading encrypted class files

An encrypted class loading process is the back stage of the ciphering. Although, a loading an encrypted classes directly is a trivial task (we only need to use our own class loader and decrypt every byte from a file with the same unique key, that we used in the ciphering process), when we trying to do the same by putting class files into the jar file the easiest is gone away. I was stuck in this problem for a couple of days or so by searching for solution. The problem is that the class files are located now in the jar archive, loading process is completely different and much harder. To implement our custom class loader we need to extend the URLClassLoader for our current situation and implement some of his methods to do a proper class decryption and loading, of course. I’ve implemented all of these tasks in CryptoClassLoader class, those extended URLClassLoader mentioned above. Therefore, if you have a particular interest in the code of the CryptoClassLoader class, you could find it in the archive provided below. He is too big to be explained right here. Our custom CryptoClassLoader is backward compatible with the preceding process of the class encryption. He just decrypts the ciphered classes and loads it in the appropriate manner from the jar archive.

Now we have a lot of work behind, but the one question is still staying annoyingly: how to use this custom ClassLoader to load the ciphered files?

This is much easier than you can imagine. Let me explain it through the code. Firstly, we need to find a location of our jar file:

CodeSource src = CryptoClassDemo.class.getProtectionDomain().getCodeSource();
URL jar = null;

if (src != null) {
      jar = src.getLocation();
}

Secondly, load the class files from this jar file. Doing so by passing two parameters: class file to load and the location of our jar archive:

private static String classFileToLoad = "com.apleben.animation.AnimatedCurves.AnimatedCurvesDemo";

try {
      loadClass(classFileToLoad, jar);
} catch (ClassNotFoundException e) {
      e.printStackTrace();
} catch (NoSuchMethodException e) {
      e.printStackTrace();
} catch (InvocationTargetException e) {
      e.printStackTrace();
}

/*
 * Runs the main method of a given encrypted class.
 *
 * @param name the class name
 * @param jar the url of the jar file
 */
private static void loadClass(final String name, URL jar) throws ClassNotFoundException,
      NoSuchMethodException, InvocationTargetException {
try {
      URLClassLoader loader = new CryptoClassLoader(publicKey, jar);
      Class<> c = loader.loadClass(name);

      Method m = c.getMethod("main", String[].class);
      m.setAccessible(true);
      int mods = m.getModifiers();

      if (m.getReturnType() != void.class || !Modifier.isStatic(mods) ||
            !Modifier.isPublic(mods)) {
            throw new NoSuchMethodException("main");
      }

      try {
            m.invoke(null, (Object) new String[]{});
      } catch (IllegalAccessException e) {
            e.printStackTrace(); // should not happen
      }
} catch (Throwable e) {
      e.printStackTrace();
}
}

Thats it! We completed our work and left any questions behind. But if you have one, do not hesitate to ask your questions right here or type me a message. The source code you may find in the archive below. In the archive you will find two jar’s:

The CryptoClassTool – that you could use to encrypt your own class files;
CryptoClassDemo – the demo that using CryptoClassLoader and previously encrypted classes.

Thank you for attention!

Animated Curves Swing Demo

Alexander Pupeikis — Sat, 13 Nov 2010 03:47:56 +0000

I thought, this is a time for a new demo application in the way of the Java Desktop. This is not a top secret for everybody, that the Java programming language is the most popular language around our world. Especially, he is very popular in the Enterprise world. Unfortunately, Java Swing desktop applications appearing in our desktop environment much rarely. The evil tongues always told about “Java was dead for desktops”. I think, that is not a truth. The activity in this way is low and slow, not just because the Java Swing is are very bad and frustrating environment to develop with, but because Swing is very hard to study and to start to develop with it. Therefore, in many cases folks just cannot realize how to deal with that in a short move. I am even not talking about the customization of the components and some of the magic incantations to create the stunning, great looking desktop applications. Well, lets do something to reduce that barrier. Probably, we need more Swing based Open Source projects to grow up this way, which could be very exciting and useful for others.

Going further

My attempt in this demo is very lightweight and simple (maybe for someone, that might look not so simple. This is just my things):

Construction of the introduction panel with custom gradient panel;
Also, the introduction panel have a custom JComponent which doing his job as a blurred and pulsing logo;
The resulting panel with the same custom gradient panel, a non-opaque curves panel and again non-opaque panel with two custom round buttons;
Two “Start” and “Stop” buttons will start or stop the animation of the curves accordingly;
The slight transition effect between two panels is playing around by the Animated Transitions library help.

Introduction Panel

That panel was build, as I obviously mentioned above, with custom gradient panel and with our not lesser customized logo. A steps after the panel’s construction are:

The panel will appear with the alpha change from 0.0f to 1.0f of the JXpanel;
The custom logo will appear from highly blurred image to the original image;
The logo will pulsing three times;
As the next step, the introduction panel will transition from current panel to the result panel, where we can play with simple curves animation.

The code of the gradient panel is simple:

public class GradientPanel extends JPanel {
    private BufferedImage gradientImage;        // gradient image cache
    private Color gradients [] = new Color[] {  // color gradients
            new Color(174, 222, 94),
            new Color(204, 249, 124),
            new Color(174, 222, 94)
    };
    // ...
    // some of the code were omitted for brevity
    // ...

    /**
     * Painting the gradient image as a background
     * {@inheritDoc}
     */
    @Override
    protected void paintComponent(Graphics g) {
        createImageCache();

        if (gradientImage != null) {
            g.drawImage(gradientImage, 0, 0, getWidth(), getHeight(), null);
        }
    }

    /*
     * creating the gradient image cache
     */
    private void createImageCache() {
        // it should not be widely, otherwise, enough for stretching the image
        int width = 2;
        int height = getHeight();

        if (height == 0) {
            return;
        }

        // image caching paradigm.
        // It should be as a rule for the big images, like a backgrounds
        if (gradientImage == null ||
                width != gradientImage.getWidth() ||
                height != gradientImage.getHeight()) {

            gradientImage = GraphicsUtilities.
                                  createCompatibleImage(width, height);
            Graphics2D g2 = gradientImage.createGraphics();

            Point2D start = new Point2D.Float(0, 0);
            Point2D end = new Point2D.Float(width, height);
            float dist [] = {0.0f, 0.5f, 1.0f};
            LinearGradientPaint gradient =
                  new LinearGradientPaint(start, end, dist, gradients);
            g2.setPaint(gradient);

            g2.fillRect(0, 0, width, height);

            g2.dispose();
        }
    }
    // ...
    // some of the code were omitted for brevity
    // ...
}

There is not so interesting as our custom logo’s code. Well, lets looks at this point! The logo has two effects, those transitioning one from another, then one effect was done another will appear. Two effects is → disappearing blur effect (in these cases I mean a reduced radius of the blur filter) as first and pulsing effect as the next one.

    /**
     * Custom blurred and finally pulsed logo.
     * After instantiation performed the two sequence of animation steps.
     */
    public static class BlurPulseLogo extends JComponent {
        private Animator glowAnimator;              // the final pulse Animator
        private BufferedImage image, glow, blurred; // just an image cache
        private int radius = 30;                    // Blur Filter radius
        private GaussianBlurFilter blurFilter;      // obviously, the Gaussian Blur Filter
        private boolean blurPaint, glowPaint;       // flags to paint the blur and pulse effects
        private float alpha = 0.0f;                 // alpha for the pulse effect painting

        public BlurPulseLogo(final String imageName) {
            try {
                image = GraphicsUtilities.loadCompatibleImage(
                                      getClass().getResource(imageName));
            } catch (IOException e) {
                e.printStackTrace();
            }
            blurFilter = new GaussianBlurFilter(radius);
            PropertySetter setter = new PropertySetter(this, "alpha", 0.0f, 1.0f);
            glowAnimator = new Animator(800, 6.0, Animator.RepeatBehavior.REVERSE, setter);
        }
        // ...
        // some of the code were omitted for brevity
        // ...

        public float getAlpha() {
            return alpha;
        }

        public void setAlpha(float alpha) {
            this.alpha = alpha;
            repaint();
        }

        public int getRadius() {
            return radius;
        }

        public void setRadius(int radius) {
            this.radius = radius;
            blurFilter = new GaussianBlurFilter(radius);
            repaint();
        }

        @Override
        protected void paintComponent(Graphics g) {
            createImageCache();

            Graphics2D g2;

            if (blurPaint) {
                g2 = blurred.createGraphics();
                g2.setComposite(AlphaComposite.Clear);
                g2.fillRect(0, 0, blurred.getWidth(), blurred.getHeight());

                g2.setComposite(AlphaComposite.SrcOver);

                if (radius > 0) {
                    g2.drawImage(image, blurFilter, 0, 0);
                } else {
                    g2.drawImage(image, null, 0, 0);
                }

                g2.dispose();
            }

            int x = (getWidth() - image.getWidth()) / 2;
            int y = (getHeight() - image.getHeight()) / 2;

            g2 = (Graphics2D) g.create();

            if (blurPaint) {
                g2.drawImage(blurred, x, y, null);
            } else if (glowPaint) {
                g2.setComposite(AlphaComposite.SrcOver.derive(getAlpha()));
                g2.drawImage(glow, x, y, null);
                g2.setComposite(AlphaComposite.SrcOver);
                g2.drawImage(image, x, y, null);
            }
            g2.dispose();
        }

        private void createImageCache() {
            if (blurred == null) {
                blurred = GraphicsUtilities.createCompatibleTranslucentImage(
                                 image.getWidth(), image.getHeight());
            }

            if (glow == null) {
                glow = GraphicsUtilities.createCompatibleImage(image);

                Graphics2D g2 = glow.createGraphics();
                g2.drawImage(image, 0, 0, null);
                g2.dispose();

                BufferedImageOp filter = new GaussianBlurFilter(24);
                glow = filter.filter(glow, null);
                filter = new ColorTintFilter(Color.WHITE, 1.0f);
                glow = filter.filter(glow, null);
            }
        }

         public void startAnimator() {
            startBlurAnimator();
        }

        private void startBlurAnimator() {
            blurPaint = true;               // we should paint blur effect
            glowPaint = false;              // but not pulse right now
            final int oldValue = getRadius();

            Animator animator = new Animator(2800, new TimingTargetAdapter() {
                @Override
                public void end() {
                    // after blur was done, just switch it off in painting code
                    blurPaint = false;
                    radius = oldValue;
                    startGlowAnimator();    // starting pulse animation
                }

                @Override
                public void timingEvent(float fraction) {
                    // is it are linear interpolation?! probably, the part of
                    int value = (int) (oldValue + fraction * (-oldValue));

                    if (value > oldValue) value = oldValue;
                    else if (value < 0) value = 0;

                    setRadius(value);   // setting the new radius and repaint
                }
            });
            animator.start();
        }

        private void startGlowAnimator() {
            glowPaint = true;
            glowAnimator.start();
        }
}

Result Panel as a result

The resulting panel contains three panels inside:

The gradient panel again;
The curves panel for animation purposes;
The buttons panel to start and stop our animation.

The code of the gradient panel were presented above and he is very boring for us. The curves panel is not sophisticated and anybody of you, who is interesting in all source code, might find it at the end of this post. Looks from another position, the source of the custom round button could be interesting. And here we go:

public class RoundButton extends JButton {

    // ...
    // some of the code were omitted for brevity
    // ...
    @Override
    protected void paintComponent(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                    RenderingHints.VALUE_INTERPOLATION_BILINEAR);

        Insets insets = getInsets();

        drawButtonImage(g2, insets);
        drawButtonText(g2, insets);
    }

    private void drawButtonImage(Graphics2D g2, Insets insets) {
        int width = getWidth() - insets.left - insets.right;
        int height = getHeight() - insets.top - insets.bottom;

        if(normalButton == null || normalButton.getWidth() != width ||
                normalButton.getHeight() != height) {
            normalButton = GraphicsUtilities.
                    createCompatibleTranslucentImage(width, height);
            Graphics2D g = normalButton.createGraphics();

            RoundRectangle2D bullet = new RoundRectangle2D.
                    Double(0.0, 0.0, width, height, height, height);
            Ellipse2D curve = new Ellipse2D.
                    Double(-20.0, height / 2.0, width + 40.0, height);

            g.translate(-1, -2);
            g.setColor(new Color(0, 0, 0, 150));
            g.fill(new RoundRectangle2D.Double(0.0, 0.0,
                    width + 2, height + 4, height + 4, height + 4));
            g.translate(1, 2);

            Color startColor = new Color(10, 0, 40);
            Color endColor = new Color(175, 165, 225);

            Paint paint = g.getPaint();
            g2.setPaint(new GradientPaint(0.0f, 0.0f, startColor,
                    0.0f, (float) height, endColor));
            g.fill(bullet);
            g.draw(bullet);

            startColor = new Color(5, 0, 50);
            endColor = new Color(105, 100, 155);
            g2.setPaint(new GradientPaint(0.0f, 0.0f, startColor,
                    0.0f, (float ) height, endColor));

            Area area = new Area(bullet);
            area.intersect(new Area(curve));
            g.fill(area);
            g.setPaint(paint);
            g.dispose();

            if(normalButtonPressed != null) {
                normalButtonPressed.flush();
                normalButtonPressed = null;
            }

            normalButtonPressed = GraphicsUtilities.
                    createCompatibleTranslucentImage(width, height);

            tintFilter.filter(normalButton, normalButtonPressed);
        }

        g2.drawImage(model.isArmed() ?
                    normalButtonPressed : normalButton, 0, 0, null);


        if(buttonHighlight == null) {
            try {
                String fileName = "/com/apleben/swing/buttons/resources/halo.png";
                buttonHighlight = ImageIO.read(
                         RoundButton.class.getResource(fileName));
                buttonHighlight = GraphicsUtilities.
                         toCompatibleImage(buttonHighlight);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (ghostValue > 0.0f) {
            float alphaValue = ghostValue;
            Composite composite = g2.getComposite();
            if (composite instanceof AlphaComposite) {
                alphaValue *= ((AlphaComposite) composite).getAlpha();
            }

            g2.setComposite(AlphaComposite.
                    getInstance(AlphaComposite.SRC_OVER,
                              alphaValue));

            g2.drawImage(buttonHighlight,
                    insets.left + 2, insets.top + 2,
                    width - 4, height - 4, null);
            g2.setComposite(composite);
        }
    }

    private void drawButtonText(Graphics2D g2, Insets insets) {
        FontMetrics fm = getFontMetrics(getFont());
        TextLayout layout = new TextLayout(getText(),
                getFont(),
                g2.getFontRenderContext());
        Rectangle2D bounds = layout.getBounds();

        float x = (float) (getWidth() - insets.left - insets.right -
                bounds.getWidth()) / 2;
        float y = (float) ((getHeight() - insets.top - insets.bottom -
                fm.getMaxAscent() - fm.getMaxDescent()) / 2) + fm.getAscent() - 1;

        if (model.isArmed()) {
            x += 1;
            y += 1;
        }

        g2.setColor(Color.BLACK);
        layout.draw(g2,
                x + (float) Math.ceil(shadowOffsetX),
                y + (float) Math.ceil(shadowOffsetY));
        g2.setColor(getForeground());
        layout.draw(g2, x, y);
    }
    // ...
    // some of the code were omitted for brevity
    // ...
}

This round button will look similar to this –>

Conclusion

So, the conclusion is simple: I don’t want to explain the boilerplate used in code, you could find the material and ideas behind the demo in a various number of graphics and Swing oriented programming books. The Swing programming may be both: a very exciting and awesome. Swing applications could be more awesome and not so boring like with standard look and feel or without any even simple effects.

The source code may be found in zip archive below or in my GitHub repository, if you like. To run this demo you should use jdk 6.10+ build, provided by Oracle, but not an OpenJDK for graphics reasons.

-Have are nice and enjoyable Swing Programming!

VMware Workstation 7.1 patch for linux kernel 2.6.35

Alexander Pupeikis — Mon, 04 Oct 2010 20:50:39 +0000

Yesterday, I arrived into a problem with Vmware modules compilation on my X64 machine running Kubuntu 10.10 aka Maverick Meerkat. The Linux kernel I am running on is 2.6.35. The exact problem occurred when I tried to compile the modules, as mentioned above and here is the log created after compilation process:

tmp/vmware-root/modules/vmmon-only/linux/hostif.c: In function ‘HostIFReadUptimeWork’:
/tmp/vmware-root/modules/vmmon-only/linux/hostif.c:2004: warning:
     ‘newUpBase’ may be used uninitialized in this function
CC [M] /tmp/vmware-root/modules/vmmon-only/linux/iommu.o
/tmp/vmware-root/modules/vmmon-only/linux/iommu.c: In function ‘IOMMU_SetupMMU’:
/tmp/vmware-root/modules/vmmon-only/linux/iommu.c:156: error:
     implicit declaration of function ‘iommu_map_range’
/tmp/vmware-root/modules/vmmon-only/linux/iommu.c: In function ‘IOMMU_VMCleanup’:
/tmp/vmware-root/modules/vmmon-only/linux/iommu.c:403: error:
     implicit declaration of function ‘iommu_unmap_range’
make[2]: *** [/tmp/vmware-root/modules/vmmon-only/linux/iommu.o] Error 1
make[1]: *** _module_/tmp/vmware-root/modules/vmmon-only Error 2
make[1]: Leaving directory `/usr/src/linux-headers-2.6.35-2-generic'
make: *** vmmon.so Error 2
make: Leaving directory `/tmp/vmware-root/modules/vmmon-only'
Unable to install vmmon

Oh, obviously the problem arrived with vmmon module compilation process. It just fails to compile!

How we can see from the compilation log, the exact problem that we arrive is the “not correct” declaration of function ‘iommu_map_range’ and ‘iommu_unmap_range’. Looks like something has been changed from the previous version of the kernel and in the current version the method signature or method declaration are not the same. Exactly, two changes gone happened:

iommu_{un}map_range → iommu_{un}map, q.v. git-commits on kerneltrap.org
fix sk_sleep references, similar to bugs.gentoo.org

After installation of VMware, the following commands patches the vmmon module sources:

cd /tmp
tar xvf /usr/lib/vmware/modules/source/vmmon.tar -C /tmp
perl -pi -e 's,_range,,' vmmon-only/linux/iommu.c
tar cvf /usr/lib/vmware/modules/source/vmmon.tar vmmon-only

But, these magic incantations does not resolve all of the problems. vmmon module was compiled successfully, although one of modules still didn’t build for me.

The solution attached below is the patch for VMware Workstation 7.1.0 build-261024 to run on the 2.6.35 linux kernel.

USE AT YOUR OWN RISK!
If it reformats your drive, steals your identity, corrupts your children, or eats your homework, that’s your problem.

In any cases, this works fine for me and I hope will work for any others too. An attachment contains the patch for linux kernel 2.6.35 and for the main line of kernel 2.6.36. Also, you’ll find the shell script for convenient way to patch the source.

Attachments: