text:
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
   <title>Javassist Tutorial</title>
   <link rel="stylesheet" type="text/css" href="brown.css">

Getting Started with Javassist

Shigeru Chiba

Next page

1. Reading and writing bytecode

2. ClassPool

3. Class loader

4. Introspection and customization

5. Bytecode level API

6. Generics

7. Varargs

8. J2ME

9. Boxing/Unboxing

10. Debug

1. Reading and writing bytecode

Javassist is a class library for dealing with Java bytecode.
Java bytecode is stored in a binary file called a class file.
Each class file contains one Java class or interface.

The class Javassist.CtClass is an abstract
representation of a class file.  A CtClass (compile-time
class) object is a handle for dealing with a class file.  The
following program is a very simple example:

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("test.Rectangle");
cc.setSuperclass(pool.get("test.Point"));
cc.writeFile();

This program first obtains a ClassPool object, which
controls bytecode modification with Javassist.  The
ClassPool object is a container of CtClass
object representing a class file.  It reads a class file on demand for
constructing a CtClass object and records the
constructed object for responding later accesses.

To modify the definition of a class, the users must first obtain
from a ClassPool object
a reference to a CtClass object representing that class.
get() in ClassPool is used for this purpose.
In the case of the program shown above, the
CtClass object representing a class
test.Rectangle is obtained from the
ClassPool object and it is assigned to a variable
cc.
The ClassPool object returned by getDefault()
searches the default system search path.

From the implementation viewpoint, ClassPool is a hash
table of CtClass objects, which uses the class names as
keys.  get() in ClassPool searches this hash
table to find a CtClass object associated with the
specified key.  If such a CtClass object is not found,
get() reads a class file to construct a new
CtClass object, which is recorded in the hash table and
then returned as the resulting value of get().

The CtClass object obtained from a ClassPool
object can be modified
(details of how to modify
a CtClass will be presented later).
In the example above, it is modified so that the superclass of
test.Rectangle is changed into a class
test.Point.  This change is reflected on the original
class file when writeFile() in CtClass() is
finally called.

writeFile() translates the CtClass object
into a class file and writes it on a local disk.
Javassist also provides a method for directly obtaining the
modified bytecode.  To obtain the bytecode, call toBytecode():

byte[] b = cc.toBytecode();

You can directly load the CtClass as well:

Class clazz = cc.toClass();

toClass() requests the context class loader for the current
thread to load the class file represented by the CtClass.  It
returns a java.lang.Class object representing the loaded class.
For more details, please see this section below.

Defining a new class

To define a new class from scratch, makeClass()
must be called on a ClassPool.

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("Point");

This program defines a class Point
including no members.
Member methods of Point can be created with
factory methods declared in CtNewMethod and
appended to Point with addMethod()
in CtClass.

makeClass() cannot create a new interface;
makeInterface() in ClassPool can do.
Member methods in an interface can be created with
abstractMethod() in CtNewMethod.
Note that an interface method is an abstract method.

Frozen classes

If a CtClass object is converted into a class file by
writeFile(), toClass(), or
toBytecode(), Javassist freezes that CtClass
object.  Further modifications of that CtClass object are
not permitted.  This is for warning the developers when they attempt
to modify a class file that has been already loaded since the JVM does
not allow reloading a class.

A frozen CtClass can be defrost so that
modifications of the class definition will be permitted.  For example,

CtClasss cc = ...;
    :
cc.writeFile();
cc.defrost();
cc.setSuperclass(...);    // OK since the class is not frozen.

After defrost() is called, the CtClass
object can be modified again.

If ClassPool.doPruning is set to true,
then Javassist prunes the data structure contained
in a CtClass object
when Javassist freezes that object.
To reduce memory
consumption, pruning discards unnecessary attributes
(attribute_info structures) in that object.
For example, Code_attribute structures (method bodies)
are discarded.
Thus, after a
CtClass object is pruned, the bytecode of a method is not
accessible except method names, signatures, and annotations.
The pruned CtClass object cannot be defrost again.
The default value of ClassPool.doPruning is false.

To disallow pruning a particular CtClass,
stopPruning() must be called on that object in advance:

CtClasss cc = ...;
cc.stopPruning(true);
    :
cc.writeFile();                             // convert to a class file.
// cc is not pruned.

The CtClass object cc is not pruned.
Thus it can be defrost after writeFile() is called.

Note:
While debugging, you might want to temporarily stop pruning and freezing
and write a modified class file to a disk drive.
debugWriteFile() is a convenient method
for that purpose.  It stops pruning, writes a class file, defrosts it,
and turns pruning on again (if it was initially on).

Class search path

The default ClassPool returned
by a static method ClassPool.getDefault()
searches the same path that the underlying JVM (Java virtual machine) has.
If a program is running on a web application server such as JBoss and Tomcat,
the ClassPool object may not be able to find user classes
since such a web application server uses multiple class loaders as well as
the system class loader.  In that case, an additional class path must be
registered to the ClassPool.  Suppose that pool
refers to a ClassPool object:

pool.insertClassPath(new ClassClassPath(this.getClass()));

This statement registers the class path that was used for loading
the class of the object that this refers to.
You can use any Class object as an argument instead of
this.getClass().  The class path used for loading the
class represented by that Class object is registered.

You can register a directory name as the class search path.
For example, the following code adds a directory
/usr/local/javalib
to the search path:

ClassPool pool = ClassPool.getDefault();
pool.insertClassPath("/usr/local/javalib");

The search path that the users can add is not only a directory but also
a URL:

ClassPool pool = ClassPool.getDefault();
ClassPath cp = new URLClassPath("www.javassist.org", 80, "/java/", "org.javassist.");
pool.insertClassPath(cp);

This program adds "http://www.javassist.org:80/java/" to the class search
path.  This URL is used only for searching classes belonging to a
package org.javassist.  For example, to load a class
org.javassist.test.Main, its class file will be obtained from:

http://www.javassist.org:80/java/org/javassist/test/Main.class

Furthermore, you can directly give a byte array
to a ClassPool object
and construct a CtClass object from that array.  To do this,
use ByteArrayClassPath.  For example,

ClassPool cp = ClassPool.getDefault();
byte[] b = a byte array;
String name = class name;
cp.insertClassPath(new ByteArrayClassPath(name, b));
CtClass cc = cp.get(name);

The obtained CtClass object represents
a class defined by the class file specified by b.
The ClassPool reads a class file from the given
ByteArrayClassPath if get() is called
and the class name given to get() is equal to
one specified by name.

If you do not know the fully-qualified name of the class, then you
can use makeClass() in ClassPool:

ClassPool cp = ClassPool.getDefault();
InputStream ins = an input stream for reading a class file;
CtClass cc = cp.makeClass(ins);

makeClass() returns the CtClass object
constructed from the given input stream.  You can use
makeClass() for eagerly feeding class files to
the ClassPool object.  This might improve performance
if the search path includes a large jar file.  Since
a ClassPool object reads a class file on demand,
it might repeatedly search the whole jar file for every class file.
makeClass() can be used for optimizing this search.
The CtClass constructed by makeClass()
is kept in the ClassPool object and the class file is never
read again.

The users can extend the class search path.  They can define a new
class implementing ClassPath interface and give an
instance of that class to insertClassPath() in
ClassPool.  This allows a non-standard resource to be
included in the search path.

2. ClassPool

A ClassPool object is a container of CtClass
objects.  Once a CtClass object is created, it is
recorded in a ClassPool for ever.  This is because a
compiler may need to access the CtClass object later when
it compiles source code that refers to the class represented by that
CtClass.

For example, suppose that a new method getter() is added
to a CtClass object representing Point
class.  Later, the program attempts to compile source code including a
method call to getter() in Point and use the
compiled code as the body of a method, which will be added to another
class Line.  If the CtClass object representing
Point is lost, the compiler cannot compile the method call
to getter().  Note that the original class definition does
not include getter().  Therefore, to correctly compile
such a method call, the ClassPool
must contain all the instances of CtClass all the time of
program execution.

Avoid out of memory

This specification of ClassPool may cause huge memory
consumption if the number of CtClass objects becomes
amazingly large (this rarely happens since Javassist tries to reduce
memory consumption in various ways).
To avoid this problem, you
can explicitly remove an unnecessary CtClass object from
the ClassPool.  If you call detach() on a
CtClass object, then that CtClass object is
removed from the ClassPool.  For example,

CtClass cc = ... ;
cc.writeFile();
cc.detach();

You must not call any method on that
CtClass object after detach() is called.
However, you can call get() on ClassPool
to make a new instance of CtClass representing
the same class.  If you call get(), the ClassPool
reads a class file again and newly creates a CtClass
object, which is returned by get().

Another idea is to occasionally replace a ClassPool with
a new one and discard the old one.  If an old ClassPool
is garbage collected, the CtClass objects included in
that ClassPool are also garbage collected.
To create a new instance of ClassPool, execute the following
code snippet:

ClassPool cp = new ClassPool(true);
// if needed, append an extra search path by appendClassPath()

This creates a ClassPool object that behaves as the
default ClassPool returned by
ClassPool.getDefault() does.
Note that ClassPool.getDefault() is a singleton factory method
provided for convenience.  It creates a ClassPool object in
the same way shown above although it keeps a single instance of
ClassPool and reuses it.
A ClassPool object returned by getDefault()
does not have a special role.  getDefault() is a convenience
method.

Note that new ClassPool(true) is a convenient constructor,
which constructs a ClassPool object and appends the system
search path to it.  Calling that constructor is
equivalent to the following code:

ClassPool cp = new ClassPool();
cp.appendSystemPath();  // or append another path by appendClassPath()

Cascaded ClassPools

If a program is running on a web application server,
creating multiple instances of ClassPool might be necessary;
an instance of ClassPool should be created
for each class loader (i.e. container).
The program should create a ClassPool object by not calling
getDefault() but a constructor of ClassPool.

Multiple ClassPool objects can be cascaded like
java.lang.ClassLoader.  For example,

ClassPool parent = ClassPool.getDefault();
ClassPool child = new ClassPool(parent);
child.insertClassPath("./classes");

If child.get() is called, the child ClassPool
first delegates to the parent ClassPool.  If the parent
ClassPool fails to find a class file, then the child
ClassPool attempts to find a class file
under the ./classes directory.

If child.childFirstLookup is true, the child
ClassPool attempts to find a class file before delegating
to the parent ClassPool.  For example,

ClassPool parent = ClassPool.getDefault();
ClassPool child = new ClassPool(parent);
child.appendSystemPath();         // the same class path as the default one.
child.childFirstLookup = true;    // changes the behavior of the child.

Changing a class name for defining a new class

A new class can be defined as a copy of an existing class.
The program below does that:

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
cc.setName("Pair");

This program first obtains the CtClass object for
class Point.  Then it calls setName() to
give a new name Pair to that CtClass object.
After this call, all occurrences of the class name in the class
definition represented by that CtClass object are changed
from Point to Pair.  The other part of the
class definition does not change.

Note that setName() in CtClass changes a
record in the ClassPool object.  From the implementation
viewpoint, a ClassPool object is a hash table of
CtClass objects.  setName() changes
the key associated to the CtClass object in the hash
table.  The key is changed from the original class name to the new
class name.

Therefore, if get("Point") is later called on the
ClassPool object again, then it never returns the
CtClass object that the variable cc refers to.
The ClassPool object reads
a class file
Point.class again and it constructs a new CtClass
object for class Point.
This is because the CtClass object associated with the name
Point does not exist any more.
See the followings:

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
CtClass cc1 = pool.get("Point");   // cc1 is identical to cc.
cc.setName("Pair");
CtClass cc2 = pool.get("Pair");    // cc2 is identical to cc.
CtClass cc3 = pool.get("Point");   // cc3 is not identical to cc.

cc1 and cc2 refer to the same instance of
CtClass that cc does whereas
cc3 does not.  Note that, after
cc.setName("Pair") is executed, the CtClass
object that cc and cc1 refer to represents
the Pair class.

The ClassPool object is used to maintain one-to-one
mapping between classes and CtClass objects.  Javassist
never allows two distinct CtClass objects to represent
the same class unless two independent ClassPool are created.
This is a significant feature for consistent program
transformation.

To create another copy of the default instance of
ClassPool, which is returned by
ClassPool.getDefault(), execute the following code
snippet (this code was already shown above):

ClassPool cp = new ClassPool(true);

If you have two ClassPool objects, then you can
obtain, from each ClassPool, a distinct
CtClass object representing the same class file.  You can
differently modify these CtClass objects to generate
different versions of the class.

Renaming a frozen class for defining a new class

Once a CtClass object is converted into a class file
by writeFile() or toBytecode(), Javassist
rejects further modifications of that CtClass object.
Hence, after the CtClass object representing Point
class is converted into a class file, you cannot define Pair
class as a copy of Point since executing setName()
on Point is rejected.
The following code snippet is wrong:

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
cc.writeFile();
cc.setName("Pair");    // wrong since writeFile() has been called.

To avoid this restriction, you should call getAndRename()
in ClassPool.  For example,

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
cc.writeFile();
CtClass cc2 = pool.getAndRename("Point", "Pair");

If getAndRename() is called, the ClassPool
first reads Point.class for creating a new CtClass
object representing Point class.  However, it renames that
CtClass object from Point to Pair before
it records that CtClass object in a hash table.
Thus getAndRename()
can be executed after writeFile() or toBytecode()
is called on the the CtClass object representing Point
class.

3. Class loader

If what classes must be modified is known in advance,
the easiest way for modifying the classes is as follows:

1. Get a CtClass object by calling
        ClassPool.get(),

2. Modify it, and

3. Call writeFile() or toBytecode()
           on that CtClass object to obtain a modified class file.

If whether a class is modified or not is determined at load time,
the users must make Javassist collaborate with a class loader.
Javassist can be used with a class loader so that bytecode can be
modified at load time.  The users of Javassist can define their own
version of class loader but they can also use a class loader provided
by Javassist.

3.1 The toClass method in CtClass

The CtClass provides a convenience method
toClass(), which requests the context class loader for
the current thread to load the class represented by the CtClass
object.  To call this method, the caller must have appropriate permission;
otherwise, a SecurityException may be thrown.

The following program shows how to use toClass():

public class Hello {
    public void say() {
        System.out.println("Hello");
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        ClassPool cp = ClassPool.getDefault();
        CtClass cc = cp.get("Hello");
        CtMethod m = cc.getDeclaredMethod("say");
        m.insertBefore("{ System.out.println(\"Hello.say():\"); }");
        Class c = cc.toClass();
        Hello h = (Hello)c.newInstance();
        h.say();
    }
}

Test.main() inserts a call to println()
in the method body of say() in Hello.  Then
it constructs an instance of the modified Hello class
and calls say() on that instance.

Note that the program above depends on the fact that the
Hello class is never loaded before toClass()
is invoked.  If not, the JVM would load the original
Hello class before toClass() requests to
load the modified Hello class.  Hence loading the
modified Hello class would be failed
(LinkageError is thrown).  For example, if
main() in Test is something like this:

public static void main(String[] args) throws Exception {
    Hello orig = new Hello();
    ClassPool cp = ClassPool.getDefault();
    CtClass cc = cp.get("Hello");
        :
}

then the original Hello class is loaded at the first
line of main and the call to toClass()
throws an exception since the class loader cannot load two different
versions of the Hello class at the same time.

If the program is running on some application server such as
JBoss and Tomcat, the context class loader used by
toClass() might be inappropriate.  In this case, you
would see an unexpected ClassCastException.  To avoid
this exception, you must explicitly give an appropriate class loader
to toClass().  For example, if bean is your
session bean object, then the following code:

CtClass cc = ...;
Class c = cc.toClass(bean.getClass().getClassLoader());

would work.  You should give toClass() the class loader
that has loaded your program (in the above example, the class of
the bean object).

toClass() is provided for convenience.  If you need
more complex functionality, you should write your own class loader.

3.2 Class loading in Java

In Java, multiple class loaders can coexist and
each class loader creates its own name space.
Different class loaders can load different class files with the
same class name.  The loaded two classes are regarded as different
ones.  This feature enables us to run multiple application programs
on a single JVM even if these programs include different classes
with the same name.

Note: The JVM does not allow dynamically reloading a class.
Once a class loader loads a class, it cannot reload a modified
version of that class during runtime.  Thus, you cannot alter
the definition of a class after the JVM loads it.
However, the JPDA (Java Platform Debugger Architecture) provides
limited ability for reloading a class.
See Section 3.6.

If the same class file is loaded by two distinct class loaders,
the JVM makes two distinct classes with the same name and definition.
The two classes are regarded as different ones.
Since the two classes are not identical, an instance of one class is
not assignable to a variable of the other class.  The cast operation
between the two classes fails
and throws a ClassCastException.

For example, the following code snippet throws an exception:

MyClassLoader myLoader = new MyClassLoader();
Class clazz = myLoader.loadClass("Box");
Object obj = clazz.newInstance();
Box b = (Box)obj;    // this always throws ClassCastException.

The Box class is loaded by two class loaders.
Suppose that a class loader CL loads a class including this code snippet.
Since this code snippet refers to MyClassLoader,
Class, Object, and Box,
CL also loads these classes (unless it delegates to another class loader).
Hence the type of the variable b is the Box
class loaded by CL.
On the other hand, myLoader also loads the Box
class.  The object obj is an instance of
the Box class loaded by myLoader.
Therefore, the last statement always throws a
ClassCastException since the class of obj is
a different verison of the Box class from one used as the
type of the variable b.

Multiple class loaders form a tree structure.
Each class loader except the bootstrap loader has a
parent class loader, which has normally loaded the class of that child
class loader.  Since the request to load a class can be delegated along this
hierarchy of class loaders, a class may be loaded by a class loader that
you do not request the class loading.
Therefore, the class loader that has been requested to load a class C
may be different from the loader that actually loads the class C.
For distinction, we call the former loader the initiator of C
and we call the latter loader the real loader of C.

Furthermore, if a class loader CL requested to load a class C
(the initiator of C) delegates
to the parent class loader PL, then the class loader CL is never requested
to load any classes referred to in the definition of the class C.
CL is not the initiator of those classes.
Instead, the parent class loader PL becomes their initiators
and it is requested to load them.
The classes that the definition of a class C referes to are loaded by
the real loader of C.

To understand this behavior, let's consider the following example.

public class Point {    // loaded by PL
    private int x, y;
    public int getX() { return x; }
        :
}

public class Box {      // the initiator is L but the real loader is PL
    private Point upperLeft, size;
    public int getBaseX() { return upperLeft.x; }
        :
}

public class Window {    // loaded by a class loader L
    private Box box;
    public int getBaseX() { return box.getBaseX(); }
}

Suppose that a class Window is loaded by a class loader L.
Both the initiator and the real loader of Window are L.
Since the definition of Window refers to Box,
the JVM will request L to load Box.
Here, suppose that L delegates this task to the parent class loader PL.
The initiator of Box is L but the real loader is PL.
In this case, the initiator of Point is not L but PL
since it is the same as the real loader of Box.
Thus L is never requested to load Point.

Next, let's consider a slightly modified example.

public class Point {
    private int x, y;
    public int getX() { return x; }
        :
}

public class Box {      // the initiator is L but the real loader is PL
    private Point upperLeft, size;
    public Point getSize() { return size; }
        :
}

public class Window {    // loaded by a class loader L
    private Box box;
    public boolean widthIs(int w) {
        Point p = box.getSize();
        return w == p.getX();
    }
}

Now, the definition of Window also refers to
Point.  In this case, the class loader L must
also delegate to PL if it is requested to load Point.
You must avoid having two class loaders doubly load the same
class.  One of the two loaders must delegate to
the other.

If L does not delegate to PL when Point
is loaded, widthIs() would throw a ClassCastException.
Since the real loader of Box is PL,
Point referred to in Box is also loaded by PL.
Therefore, the resulting value of getSize()
is an instance of Point loaded by PL
whereas the type of the variable p in widthIs()
is Point loaded by L.
The JVM regards them as distinct types and thus it throws an exception
because of type mismatch.

This behavior is somewhat inconvenient but necessary.
If the following statement:

Point p = box.getSize();

did not throw an exception,
then the programmer of Window could break the encapsulation
of Point objects.
For example, the field x
is private in Point loaded by PL.
However, the Window class could
directly access the value of x
if L loads Point with the following definition:

public class Point {
    public int x, y;    // not private
    public int getX() { return x; }
        :
}

For more details of class loaders in Java, the following paper would
be helpful:

Sheng Liang and Gilad Bracha,
"Dynamic Class Loading in the Java Virtual Machine",

ACM OOPSLA'98, pp.36-44, 1998.

3.3 Using javassist.Loader

Javassist provides a class loader
javassist.Loader.  This class loader uses a
javassist.ClassPool object for reading a class file.

For example, javassist.Loader can be used for loading
a particular class modified with Javassist.

import javassist.*;
import test.Rectangle;

public class Main {
  public static void main(String[] args) throws Throwable {
     ClassPool pool = ClassPool.getDefault();
     Loader cl = new Loader(pool);

     CtClass ct = pool.get("test.Rectangle");
     ct.setSuperclass(pool.get("test.Point"));

     Class c = cl.loadClass("test.Rectangle");
     Object rect = c.newInstance();
         :
  }
}

This program modifies a class test.Rectangle.  The
superclass of test.Rectangle is set to a
test.Point class.  Then this program loads the modified
class, and creates a new instance of the
test.Rectangle class.

If the users want to modify a class on demand when it is loaded,
the users can add an event listener to a javassist.Loader.
The added event listener is
notified when the class loader loads a class.
The event-listener class must implement the following interface:

public interface Translator {
    public void start(ClassPool pool)
        throws NotFoundException, CannotCompileException;
    public void onLoad(ClassPool pool, String classname)
        throws NotFoundException, CannotCompileException;
}

The method start() is called when this event listener
is added to a javassist.Loader object by
addTranslator() in javassist.Loader.  The
method onLoad() is called before
javassist.Loader loads a class.  onLoad()
can modify the definition of the loaded class.

For example, the following event listener changes all classes
to public classes just before they are loaded.

public class MyTranslator implements Translator {
    void start(ClassPool pool)
        throws NotFoundException, CannotCompileException {}
    void onLoad(ClassPool pool, String classname)
        throws NotFoundException, CannotCompileException
    {
        CtClass cc = pool.get(classname);
        cc.setModifiers(Modifier.PUBLIC);
    }
}

Note that onLoad() does not have to call
toBytecode() or writeFile() since
javassist.Loader calls these methods to obtain a class
file.

To run an application class MyApp with a
MyTranslator object, write a main class as following:

import javassist.*;

public class Main2 {
  public static void main(String[] args) throws Throwable {
     Translator t = new MyTranslator();
     ClassPool pool = ClassPool.getDefault();
     Loader cl = new Loader();
     cl.addTranslator(pool, t);
     cl.run("MyApp", args);
  }
}

To run this program, do:

% java Main2 arg1 arg2...

The class MyApp and the other application classes
are translated by MyTranslator.

Note that application classes like MyApp cannot
access the loader classes such as Main2,
MyTranslator, and ClassPool because they
are loaded by different loaders.  The application classes are loaded
by javassist.Loader whereas the loader classes such as
Main2 are by the default Java class loader.

javassist.Loader searches for classes in a different
order from java.lang.ClassLoader.
ClassLoader first delegates the loading operations to
the parent class loader and then attempts to load the classes
only if the parent class loader cannot find them.
On the other hand,
javassist.Loader attempts
to load the classes before delegating to the parent class loader.
It delegates only if:

the classes are not found by calling get() on
a ClassPool object, or

the classes have been specified by using
delegateLoadingOf()
to be loaded by the parent class loader.

This search order allows loading modified classes by Javassist.
However, it delegates to the parent class loader if it fails
to find modified classes for some reason.  Once a class is loaded by
the parent class loader, the other classes referred to in that class will be
also loaded by the parent class loader and thus they are never modified.
Recall that all the classes referred to in a class C are loaded by the
real loader of C.
If your program fails to load a modified class, you should
make sure whether all the classes using that class have been loaded by
javassist.Loader.

3.4 Writing a class loader

A simple class loader using Javassist is as follows:

import javassist.*;

public class SampleLoader extends ClassLoader {
    /* Call MyApp.main().
     */
    public static void main(String[] args) throws Throwable {
        SampleLoader s = new SampleLoader();
        Class c = s.loadClass("MyApp");
        c.getDeclaredMethod("main", new Class[] { String[].class })
         .invoke(null, new Object[] { args });
    }

    private ClassPool pool;

    public SampleLoader() throws NotFoundException {
        pool = new ClassPool();
        pool.insertClassPath("./class"); // MyApp.class must be there.
    }

    /* Finds a specified class.
     * The bytecode for that class can be modified.
     */
    protected Class findClass(String name) throws ClassNotFoundException {
        try {
            CtClass cc = pool.get(name);
            // modify the CtClass object here
            byte[] b = cc.toBytecode();
            return defineClass(name, b, 0, b.length);
        } catch (NotFoundException e) {
            throw new ClassNotFoundException();
        } catch (IOException e) {
            throw new ClassNotFoundException();
        } catch (CannotCompileException e) {
            throw new ClassNotFoundException();
        }
    }
}

The class MyApp is an application program.
To execute this program, first put the class file under the
./class directory, which must not be included
in the class search path.  Otherwise, MyApp.class would
be loaded by the default system class loader, which is the parent
loader of SampleLoader.
The directory name ./class is specified by
insertClassPath() in the constructor.
You can choose a different name instead of ./class if you want.
Then do as follows:

% java SampleLoader

The class loader loads the class MyApp
(./class/MyApp.class) and calls
MyApp.main() with the command line parameters.

This is the simplest way of using Javassist.  However, if you write
a more complex class loader, you may need detailed knowledge of
Java's class loading mechanism.  For example, the program above puts the
MyApp class in a name space separated from the name space
that the class SampleLoader belongs to because the two
classes are loaded by different class loaders.
Hence, the
MyApp class cannot directly access the class
SampleLoader.

3.5 Modifying a system class

The system classes like java.lang.String cannot be
loaded by a class loader other than the system class loader.
Therefore, SampleLoader or javassist.Loader
shown above cannot modify the system classes at loading time.

If your application needs to do that, the system classes must be
statically modified.  For example, the following program
adds a new field hiddenValue to java.lang.String:

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("java.lang.String");
CtField f = new CtField(CtClass.intType, "hiddenValue", cc);
f.setModifiers(Modifier.PUBLIC);
cc.addField(f);
cc.writeFile(".");

This program produces a file "./java/lang/String.class".

To run your program MyApp
with this modified String class, do as follows:

% java -Xbootclasspath/p:. MyApp arg1 arg2...

Suppose that the definition of MyApp is as follows:

public class MyApp {
    public static void main(String[] args) throws Exception {
        System.out.println(String.class.getField("hiddenValue").getName());
    }
}

If the modified String class is correctly loaded,
MyApp prints hiddenValue.

Note: Applications that use this technique for the purpose of
overriding a system class in rt.jar should not be
deployed as doing so would contravene the Java 2 Runtime Environment
binary code license.

3.6 Reloading a class at runtime

If the JVM is launched with the JPDA (Java Platform Debugger
Architecture) enabled, a class is dynamically reloadable.  After the
JVM loads a class, the old version of the class definition can be
unloaded and a new one can be reloaded again.  That is, the definition
of that class can be dynamically modified during runtime.  However,
the new class definition must be somewhat compatible to the old one.
The JVM does not allow schema changes between the two versions.
They have the same set of methods and fields.

Javassist provides a convenient class for reloading a class at runtime.
For more information, see the API documentation of
javassist.tools.HotSwapper.

Next page

Java(TM) is a trademark of Sun Microsystems, Inc.

Copyright (C) 2000-2014 by Shigeru Chiba, All rights reserved.

redpajama_set_name: RedPajamaGithub


text:
Q: Beautifulsoup python error(10060)Emergency i am new to programming , i have created a webscraper in python using beautiful soup but when i run this program it opens python command line and and just cursor blink on it and nothing happens...and now i receive these error
TimeoutError: [WinError 10060] A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond
ConnectionResetError: [WinError 10054] An existing connection was forcibly closed by the remote host
...please dont mind the indentation,
below are my codes:
import urllib.request
import urllib
import json
import xml.etree.ElementTree as ET
import csv
from bs4 import BeautifulSoup

link = 'https://maharerait.mahaonline.gov.in/searchlist/searchlist'
talukaLink = "https://maharerait.mahaonline.gov.in/SearchList/GetTaluka"
distlink = "https://maharerait.mahaonline.gov.in/SearchList/GetDistrict"
prjLink = "https://maharerait.mahaonline.gov.in/SearchList/GetProjectName"

alldata = []

links = {}
certificatedata = []

def getData(url, values):
    data = urllib.parse.urlencode(values)
    data = data.encode('utf-8')
    req = urllib.request.Request(url, data)
    response=urllib.request.urlopen(req)
    data = response.read()
    data = data.decode("utf-8")
    return data

def getDivsion():
    ## for now we are taking 6 districts.. it needs to updated when the data
gets updatedd
    return range(1,7)

  def getDistrict(divId):
      global distlink
      values = {'DivID': divId}
      data = getData(distlink, values)
    return data

def parseJson(data):
    parsed = json.loads(data)
    return parsed

def getTaluka(disId):
   global talukaLink
   values= {'DisID': disId}
   data = getData(talukaLink, values)
    return data

def getProjects(divId, disId):
    global prjLink
    values= {'DisID': disId, 'DivID': divId}
    #print(values)
    data = getData( prjLink, values)
    if len(data)<10:
    return "{}"
return data

def getProjectsList():
    divList = getDivsion()
    flag = 0
    for divId in divList:
        disData = getDistrict(divId)
        disList = parseJson(disData)
        for disObj in disList:
            disId = disObj["ID"]
            prjData = getProjects(divId, disId)
        #print(" >>>> "+str(disId)+" >> "+str(divId))
        #print(prjData)
        prjJson = parseJson(prjData)
        for prjObj in prjJson:
            flag += 1
            prjId = prjObj["ID"]
            values = {'ID':0, 'pageTraverse': 1, 'Division': divId,     'hdnDistrict': '', 'hdnProject':'', 'District': disId, 'Taluka':'', 'Village': '', 'Project': prjId, 'CertiNo':'', 'btnSearch':'Search'}
            finalPrjData = getData(link, values)
            parseXMLData(finalPrjData)
            #if len(alldata)>100:
            #    break

def parseXMLData(htmldata):
    global alldata, links
    soup = BeautifulSoup(htmldata, "html.parser")
    tables = soup.find_all("table")
    for table in tables:
        print(len(alldata))
    attr = table.attrs
    if "table" in attr['class']:
        tbody = table.find_all("tbody")
        if len(tbody)>0:
            tbody = tbody[0]
            tr_lst = tbody.find_all("tr")
            for tr in tr_lst:
                sublist = []
                td_lst = tr.find_all("td")
                if len(td_lst)>6:
                    prjname = td_lst[1].text
                    proname = td_lst[2].text
                    certNo = td_lst[3].text
                    sublist.append(prjname)
                    sublist.append(proname)
                    sublist.append(certNo)
                    td = td_lst[4]
                    a_lst = td.find_all("a")
                    if len(a_lst)>0:
                        a = a_lst[0]
                        href = a.attrs['href']
                        link = "https://maharerait.mahaonline.gov.in/"+href
                        links[certNo] = link
                        sublist.append(link)
                if len(sublist)>0:
                    alldata.append(sublist)
return alldata

def writedata(alldata1, filename):
    print(" >>>> FINAL PRINTING DATA >>>> ")
    #import pdb; pdb.set_trace()
    with open("./"+filename,'w') as csvfile:
        csvfile = csv.writer(csvfile, delimiter=',')
        #csvfile.writerow(titleRow)
        csvfile.writerow("")
        for i in range(0, len( alldata1 )):
            #print(alldata1[i])
            csvfile.writerow( alldata1[i]  )

def processlinksforcert():
    global links, certificatedata
    print(">> Came in fetching certificates data >>> " )
    for certno in links.keys():
        link = links[certno]
        htmldata = getData(link, {})
        soup = BeautifulSoup(htmldata, "html.parser")
        divs = soup.find_all("div")
        for div in divs:
            attr = div.attrs
        if "id" in attr.keys() and "DivProfessional" in attr['id']:
            table = div.find_all("table")
            if len(table)<=0:
                continue
            t_attr = table[0].attrs
            if "table" in t_attr["class"]:
                print(len(certificatedata))
                table = table[0]
                tr_lst = table.find_all("tr")
                index = 1
                while index<len(tr_lst):
                    #import pdb; pdb.set_trace()
                    #for tr in tr_lst:
                    #if index==0:
                    #    continue
                    tr = tr_lst[index]
                    index += 1
                    sublist = []
                    td_lst = tr.find_all("td")
                    if len(td_lst)>2:
                        sublist.append(certno)
                        pername = formattext( td_lst[0].text)
                        cerno = formattext( td_lst[1].text )
                        proftype = formattext( td_lst[2].text )
                        sublist.append(pername)
                        sublist.append(cerno)
                        sublist.append(proftype)
                        certificatedata.append(sublist)
return certificatedata

def formattext(text):
    while text.find("\r\n")>=0:
        text = text.replace("\r\n","")

while text.find("   ")>=0:
    text = text.replace("   ","")
return text

def main():
    global alldata, certificatedata
    #data = getData(url, {})
    getProjectsList()
    print("Before write the projects data to the file. Count >>
"+str(len(alldata)))
    writedata(alldata, "data.csv")
    data = processlinksforcert()
    print("Before write the certificates data to the file. Count >>
"+str(len(data)))
    writedata( data, "certificates.csv" )

main()

can someone pleases suggest what am i doing wrong...i have everything installed pip and pip beautifulsoup also..please dont mind the indentation, it is just for here....

A: I solved it by using selenium. Thank you so much everyone

redpajama_set_name: RedPajamaStackExchange


text:
Howe et al.
color me confused
Meet the United States of divided climate beliefs
By Suzanne Jacobs on Apr 7, 2015
If the United States were a person — let's call her Mavis — and you asked Mavis for her thoughts on climate change, then, according to a new study out of Yale, you'd probably get a rambling, semi-coherent response that's at once predictable, confusing, frightening, and utterly fascinating.
"Hey, Mavis," you might say, "are you worried about global warming?"
"Oh, I don't know," Mavis would say. "On the one hand, the liberal cities in me are concerned. On the other hand, the Wyoming in me is pretty chill about it. At the same time, parts of me like Hendry County, Florida, and the southwest border of Texas feel a little unsettled, while the northern part of Texas feels fine."
"Sounds like you're pretty conflicted, Mavis."
"Tell me about it! It doesn't help that scientists don't seem to agree on what's going on. Who knows if humans are even causing this!"
"Hmm. Do you think we should regulate CO2 pollution?"
"Absolutely. Across the board. And while we're at it, we should definitely be funding renewable energy research."
Oh, Mavis, you beautiful, complicated mess.
For a deeper look into the psyche of Mavis, check out these maps from the Yale Project on Climate Change Communication (I'd call them brain scans, but that would be taking this metaphor too far, right?). The maps, along with this article in the most recent issue of Nature Climate Change, show how public opinion on climate change varies across the country by state, congressional district, and even county.
Here are state-level results for four of the 14 questions the researchers looked at in their analysis:
a–d, The maps depict the percentage of American adults in each state who believe that global warming is happening (a); believe global warming is mostly human-caused (b); believe that most scientists think global warming is happening (c); somewhat or strongly support the regulation of CO2 as a pollutant (d). Left-hand panels depict the projected population percentages, whereas right-hand panels depict the relative differences from the national average to facilitate comparisons between states. (Howe et al.)
Where these maps came from is actually a little complicated, because you'd need a crazy number of participants to get this level of detail from surveys alone. Instead, while the researchers did use national survey data, they took the demographic and geographic information about each person (there were more than 12,000), threw some fancy math at it, and were able to estimate how certain types of people from certain areas would answer the climate change questions. By matching those answers to U.S. census data, they were able to fill in every corner on the map, even though they didn't actually have responses from about 40 percent of counties in the country (for what it's worth, those counties only represent about 6.5 percent of the U.S. population).
To test the method, the researchers compared their results to independent survey data from four states and two cities. These charts show pretty impressive agreement between the two datasets (the closer the dot is to the dotted line, the better the match):
a, Colorado. b, Texas. c, Ohio. d, California. e, Columbus, Ohio. f, San Francisco, California.Howe et al.
The researchers estimate that their data is accurate to within 5 percentage points at the state level, and 7 percentage points at the congressional district level, and 8 percentage points at the county level.
Peter Howe, lead author on the study and a professor in the Department of Environment and Society at Utah State University, pointed out that the maps reveal surprising variability in public opinion in places that often get stereotyped. A lot of people assume that Texas, for example, aren't on board with climate change, Howe said, but it turns out that people in parts of the state that border Mexico do care. That could be because Latinos are one of the ethnic groups most concerned about climate change, he said.
Howe and his colleagues plan to update the maps as they get new survey data and look at how opinions change over time, but for now, this first round of analysis offers plenty of food for thought. "The longer that you look at these," Howe says, "the more interesting stories you see, and the more you want to dig in and figure out what's going on."
Sounds like it's time for Mavis to see a therapist.
More in Science	All Science
a second wind
Today's wind turbine blades could become tomorrow's bridges
Don't need a weatherman
Climate change could take weather patterns back to the Pliocene
PROPAGANDA 101
This new game tries to vaccinate you against fake news
Plants mapped
Wild crops could save our food system — if we don't destroy them first

redpajama_set_name: RedPajamaCommonCrawl


Purple tartan ribbon is extremely popular but we we appreciate that many customers, perhaps unfamiliar with tartan names, may search for tartan ribbon by colour so please use the links below for tartan ribbon based on Purple shades. This list is not exhaustive so please explore the tartans on the buttons listed to the left, but here are the most obvious suggestions . . .
An excellent tartan in its own right, but also used as an extremely close alternative to many modern commercial tartans including Spirit of Bannockburn, Spirit of Scotland, Scotland Forever, Scotland's Heritage, Scotland The Brave, Pride of Scotland and many more.
A modern tartan, produced by McCalls Highlandwear for the hire market.
A variation of the Pride of Scotland (Modern) tartan, with more green in the check that the original version.


This is a residential class and includes room and food.
at the same location on Labor Day Weekend.
This course includes both Advanced Reiki Training and Reiki Master Training. You will be able to initiate students into all levels of Reiki including full Reiki master. The class is taught as the Usui/Tibetan style of Reiki that is a combination of the Usui system as taught by Mrs. Takata and a special Tibetan style. The Usui and Tibetan master symbols are included along with Reiki meditation, Reiki psychic surgery, Reiki Healing Attunement and many additional techniques not usually taught by others. The training is intensive and very thorough. It includes lecture, discussion, demonstration and adequate practice time. All issues and questions are dealt with openly in a very helpful and informative way. All attunements are explained, demonstrated and practiced so that each student becomes confident in their use. This is an excellent class for those wanting to be Reiki masters as well as those Reiki masters want to deepen their understanding.
A 130 page class manual is included with step by step instruction for all techniques and initiations. A certificate is included. CEs and CEUs are also available for nurses and massage therapists.
for lodging and meals for a semi-private room.
is $175 a night for lodging and meals.
Check in 4-6 p.m. on 8/27 Class begins at 9 a.m. 8/28.
Depart 8/30 at 6 p.m.
A non-refundable deposit of $575 is required to reserve your space.
August 15th unless other arrangements are made.
or after the classes. The cost is $175/person for each additional night.
PLEASE-Do not call to book your own room.
We are handling all the reservations for the classes.
Including extra nights if needed...we will SAVE YOU MONEY!
Click on any of the city links below for a map.
can get it FREE by clicking here and then click on "Get Adobe Reader"
In the course of learning the healing techniques and attunements, we'll be practicing on each other and be deeply healed as well. This will be a wonderful class and I look forward to seeing you.
you will also be required to send a copy of your Reiki II certificate.


Welcome to the Upper Valley Farm to School Network! The Network is all the educators, farmers and community members working to integrate local food and farms into the classrooms, cafeterias and communities of our region. Our staff is available to help you with your farm to school projects, be they large or small, so please contact us.
Our staff is here to support your farm to school work.
Tools for farm to school program growth.
Network members around the Upper Valley.
Each of these Upper Valley schools has a unique farm to school program. Some are as simple as a school garden bed, others involve yearly harvest parties, curricular integration, and local purchasing in the cafeteria. Contact us to get involved, or to expand your own farm to school programming.
Funding for the Upper Valley Farm to School Network is provided by the Wellborn Ecology Fund of the New Hampshire Charitable Foundation – Upper Valley Region, Jane B. Cook 1983 Charitable Trust, The Jack and Dorothy Byrne Foundation, and The Couch Family Foundation.


Pisces is the last in the circle of 12 signs of the Zodiac. All circles are infinite and have no beginning and no end.
All New Moons mark the beginning of a new cycle as the moon disappears for 2.1/2 days. This is a very powerful New Moon to set new intentions with and to release the past for many reasons. Pisces represents the end of life and the return to the source from where we came. It is a sign or release, of letting go, of forgiveness and compassion and releasing from the physical world to join with our ancestors. Pisces is the completion of our human journey and now we have to deal with whatever karma we have experienced and accumulated in our lifetime and to prepare for the next soul adventures.
This is a New Moon of initiations, and of releasing and the beginning of a major new 7-year cycle in the world.
Pisces, governed by planet Neptune, which has traveled through its own sign since April 4, 2011. We are deep sea diving with the Fisher of Signs until January 26, 2026.NOTE this year- to URANUS in TAURUS- below. During this time Neptune is at its greatest strength and we are fully feeling all of the aspects that Neptune brings- an interest in all things spiritual, and occult, which have been hidden or repressed, addictions, fake news, illusions, delusions, projection, dreams, hallucinogenic drugs, mental illness, prisons, torture, institutions, secrets, karma, drugs, and Idolizing glamour.
The New Moon is a Neptunian Sandwich of the Sun and the Moon conjunct Neptune.
This most Neptunian of New Moons will make you feel like you are in a dream. Addictions will be seducing you. You must stay grounded and have your shields up.
The Pisces New Moon also features Neptune Cazimi Sandwiched in the heart of the Sun March 6. This is extremely exalted. A perfect time to do magic, meditate on receiving from Source and beamed up in the Light of Unconditional Love.
Mars in Taurus sextiles the SUN MOON MERCURY CAZIMI Vesta sandwich.
Of course Mercury has just turned Retrograde on March 5 at 29 degrees Pisces and will turn Stationary Direct on March 28 @ 16+ Pisces which is conjunct the degree of this New Moon and it will re-touch off this Lunation's energies. You may have to wait until March 28 before you see results.
The New Moon is conjunct Fixed Star Achernar, the Mouth of a river in the constellation of Eridanus. A positive star it is symbolized by the Cherub and the Sword. It rules the center of the Left foot. Pisces rules the feet. If your feet start to cramp or vibrate you are feeling the energy of this lunation and the stars. I've been feeling it since yesterday.
Jupiter the traditional ruler of Pisces is also squaring the Lunation and all those planets too, from 22 Sagittarius boosting the gifts of higher knowledge and spiritual law which Jupiter governs.
Ceres is also squaring the SUN MOON NEPTUNE and VESTA group from Sagittarius reminding us all to REMEMBER your MOTHER the EARTH as we will be largely off planet and in the ethers. CERES has a COME HOME sign flashing.
URANUS enters TAURUS today too where the planet of chaos change revolution hi-tech and higher consciousness will remain until April 25, 2026. That's a much bigger article. Uranus is in its fall in Taurus it is exalted in Scorpio. so this is part of the conundrum having the planet of extreme change in the most resistant of signs.
Serious Saturn and Pluto are shacking up and are only 4 degrees apart with Pluto sitting on the South Node at the last karmic saloon. They are really holding this new moon down to earth and that's a good thing.
We are starting a new spiritual firey blast of healing zapping energy. Things will change quickly. As Mercury Retrogrades back over Chiron's recent territory, we will be picking up clues about that future progress in our intuition meditations and dreams.
The veils between the worlds will be very thin indeed. Vesta the Asteroid of Focus is conjunct Neptune too and will also be In The Heart of the Sun on March 7 @ 2:12 pm PST/ 5:12 pm EST/ 10:12 p,m GMT. if you want to focus on Goddess Vesta's gifts.
It's important to stay grounded and have shields up. Cleansing baths and lots of dreaming and meditating is recommended. Dreams will be very stong and lucid.
WIth the Retrograde Mercury influence, old lovers and past karmic situations will be flashing to get your attention. Be careful to release old karmic addictions and patterns and to make way for this new era.
If your birthday falls within 2 days before or after this date you will feel the effects very strongly. Take time out to integrate the fairy land and lost in the dream energies if you can.
With all this Pisces overload Your addictions may be pulling on you very strongly. if you feel overwhelmed lost hopeless or suicidal get professional help.
The Equinox is coming soon. Prepare for that the ideal time for cleansing and renewal.


text:
USS Enterprise, Navy's First Nuclear-Powered Aircraft Carrier, Inactivated
December 3, 2012 09:48 AM
Enterprise, Navy's First Nuclear-Powered Aircraft Carrier, Inactivated
Story Number: NNS121201-03Release Date: 12/1/2012 2:41:00 PM
From USS Enterprise Public Affairs
NORFOLK (NNS) -- Nearly 12,000 past and current crewmembers, family and friends attended the inactivation of aircraft carrier USS Enterprise (CVN 65) Dec. 1, 2012, at Naval Station Norfolk, Va.
Enterprise, the world's first nuclear powered aircraft carrier, recently completed its 25th and final deployment and returned to its homeport of Naval Station Norfolk for a scheduled inactivation, held prior to the ship's terminal offload program and subsequent decommissioning.
The inactivation ceremony was the last official public event for the ship, and served as a celebration of life for the ship and the more than 100,000 Sailors who served aboard.
The Chief of Naval Operations, the Commander of United States Fleet Forces, nine of twenty-three prior commanding officers, many decorated war heroes, and thousands of Enterprise veterans attended the event.
"Enterprise is a special ship and crew, and it was special long before I got here" said Captain William C. Hamilton, Jr., the twenty-third and final commanding officer, during the ceremony.
"Before I took command of this ship, I learned the definition of 'enterprise', which is 'an especially daring and courageous undertaking driven by a bold and adventurous spirit.' Fifty-one years ago, this ship was every bit of that definition."
"Here we are 51 years later," he continued, "celebrating the astonishing successes and accomplishments of this engineering marvel that has roamed the seas for more than half the history of Naval Aviation. Daring, courageous, bold, and adventurous indeed."
In honor of that spirit, Secretary of the Navy Ray Mabus, in a video message played at the ceremony, announced that the name Enterprise will live on as the officially passed the name to CVN-80, the third Ford class carrier and the ninth ship in the U.S. Navy to bear the name.
Commissioned on November 25, 1961, the eighth ship to bear the illustrious name Enterprise, the "Big E" was the world's first nuclear-powered aircraft carrier.
A veteran of 25 deployments to the Mediterranean Sea, Pacific Ocean, and the Middle East, Enterprise has served in nearly every major conflict to take place during her history. From the Cuban Missile Crisis in 1962 to six deployments in support of the Vietnam conflict through the Cold War and the Gulf Wars, Enterprise was there. On September 11, 2001, Enterprise aborted her transit home from a long deployment after the terrorist attacks, and steamed overnight to the North Arabian Sea. Big 'E' once again took her place in history when she launched the first strikes in direct support of Operation Enduring Freedom.
More than 100,000 Sailors and Marines have served aboard Enterprise during its lifetime, which has included every major conflict since the Cuban Missile Crisis. It has been home ported in both Alameda, Calif., and Norfolk, Va., and has conducted operations in every region of the world.
For more information on USS Enterprise, her legendary history, and Inactivation Week, please visit http://www.navy.mil/submit/display.asp?story_id=70899.
For news from Enterprise's final deployment, pictures of the Inactivation Ceremony, and video footage of the event, log onto www.navy.mil/local/cvn65.
Visit the ship's Facebook page at www.facebook.com/USS.Enterprise.CVN.65
 Tags:


I inherited a small house in a small village near Marianske Lazne, which I'm renovating currently to be used as a weekend-home.
Unfortunately the fixed-line Internet-connections are the poorest possible. DSL with 2MBit/s and only 128KBit/s up.
Of course I understand the technical problems for network providers they have in rural areas with far distances. However, as it can be seen in the Scandinavian Countries, it's possible to solve that problems with Fibre to the Home technologies.
So I was wondering if there are any providers in the Cheb-Area offering fast Internet connections even in very small villages. Without being able to speak czech the google-search was not successful.
The best option I found was the LTE-offer from O2, however this is limited to 30GB of traffic per month which is not enough for a fixed line.
Hello. So far I know the UPC focuses on high speed internet. You can check the availability on the website. It has an English version.
I was already in contact with UPC, but they have activities only in the big cities Prague and Brno.
I am not familiar with any fixed line internet options in your area.
Have you looked at the offerings from T-Mobile? I see that they have a package for LTE internet - "Internet na doma" with a 100 GB monthly data limit.
I did not see the plan listed on their English language pages.
yep I found that a while ago. Unfortunately the T-Mobile LTE is not available at my home. I even can't finish the order-process on the T-Mobile website as soon I enter my full address.
The O2 LTE is available, but their largest offer is 30GB/month which is definately not enough.


This blog has moved to the Election Law @ Moritz site and can be found here: http://moritzlaw.osu.edu/blogs/tokaji/. Please reset your bookmarks! Archives up to November 30, 2004 will remain here, but can be accessed through the new location.


Block Island, RI is about halfway across Block Island Sound between Montauk, NY and Newport, RI. Until we started sailing I had never heard of the place! It was a nice place to start our New England adventure.
In 1865 a channel was cut to open the Islands Salt Pond to the ocean and create a very protected anchorage and a great location from which to explore the island.
You just have to look around a little and know you are no longer in the Mid-Atlantic. There is a definitely a difference in the architecture!
I got a kick out of this, a pickup truck from Texas with surfboards parked in a lot in Rhode Island….just me?
(L-R) SV Braveheart (Mike & Kathy), SV Exuberant (Bert & Pru), Annette. Magnolia and Exuberant have crossed paths up and down the coast all the way to Georgetown Bahamas and always fun catching up with them. We met Braveheart on our way up the Jersey coast. Yes you make friends 20 miles offshore sometimes….
(L-R) MV Amici (Ted & Sally), Anthony. Our hosts for the evening were Ted & Sally who we met through Exuberant. See how crazy it can get sometimes. None the less Ted is an excellent cook and we all made contributions to the wide array of dishes. A fun night and look forward to meeting up again. Thanks again, Ted & Sally!!!
The other memorable moment from Block Island was the 193 Amp Hour day achieved by the solar panels. An epic achievement to say the least!!!


You enjoy being in nature, you want to know and see more than the usual, you want an experience beyond what every tourist does in Skopje, then go for Skopje's surrounding beauties !
During this half-day spent in nature you will feel as been somewhere far from the city but not a dozen kilometers away from it! Our experienced guide, with a cable-car system, will take you up to the Millennium Cross on the top of Mount Vodno, for a spectacular panoramic view on Skopje, the tour will also take you to the nearby village of Gorno Nerezi, at St. Pantelejmon church, to witness the frescoes that are among the highest achievements in existing Byzantine art, and last but not least – the canyon Matka, one of the most popular outdoors destinations in the surrounding of Skopje, authentic nature, presented by the many endemic species of plants, animals and butterflies.


With a staff of six graduate foresters and an agriculture business major, we have the education and experience to help you realize the maximum potential of your timberland or recreational property. While specializing in establishing and growing pine plantation timber, Louisiana's #1 Cash Crop, we also encourage hardwood retention and management which benefits wildlife habitat and water quality protection. We incorporate the goals and requests of each forestland owner with standard industry practices to accomplish satisfactory results for the present and future landowner.
Landowners view their property in many different ways. Some see it as a family legacy. Others enjoy the recreation aspect that woodlands offer or maybe wildlife habitat is of extreme importance. Many simply look at it as an asset to be used when needed. Whatever your thoughts are, our foresters will work to help you identify and reach the goals you wish to accomplish with your timberland. A combination of long and short term goals give guidance as we develop and execute your plan. As a result, you gain confidence and have peace of mind in knowing where you are and what to expect in the years ahead.
One aspect of everyone's management plan is income. Your timber sale should be a planned event. Avoid crisis sales when possible. Mistakes are made when you are anxious and not thinking clearly. Because we are actively involved in the market place every day, we are well qualified to help you decide what, when, where, and how to best market your product.
As part of our commitment to leave future generations with an abundant, healthy forest, we always encourage reforestation of clearcuts or final-harvested tracts in order to reestablish a productive, new forest stand. We provide the planning, implementation, and supervision needed to reestablish a quality new forest.
Appraisals are needed for a variety of reasons. Estate planning, mortgage requirements, inventory, and purchase or sale evaluations are a few examples. Our foresters are familiar with working with lawyers and accountants while producing a clear, professional and well- presented timber appraisal.
Copyright © 2019 Timberland Services, LLC. All rights reserved. Website by James Bobbitt, LLC.