Notices tagged with 8

This Week in #Lubuntu Development #8
https://lubuntu.me/this-week-in-lubuntu-development-8/
"Here is the eighth issue of This Week in Lubuntu Development. You can read the last issue here." #gnu #linux #ubuntu

Comment vous manipule-t-on par le Non ? - XP Horizon #8 https://www.youtube.com/watch?v=GVFA1V_Yh8s via @wallabagapp

LibreOffice is now available for Haiku

Hi there, just wanted to let everyone know that we have LibreOffice working and it already can be installed via HaikuDepot. https://depot.haiku-os.org/libreoffice Since this is a preliminary version…

Article word count: 643

HN Discussion: https://news.ycombinator.com/item?id=17440862

Posted by vermaden (karma: 197)

Post stats: Points: 116 - Comments: 26 - 2018-07-02T11:47:09Z

#HackerNews #available #for #haiku #libreoffice #now

Article content:

[1]Diver 2018-06-06 07:15:03 UTC #1

Hi there, just wanted to let everyone know that we have LibreOffice working and it already can be installed via HaikuDepot. [2]https://depot.haiku-os.org/libreoffice

Since this is a preliminary version it has some known issues:

 * It closes the very first time you launch it (it creates a user profile in ~/config/settings/libreofficedev)
 * You can’t change the font - everything is rendered using the same font
 * Only menubar looks native, many widgets are just bitmaps which come from the icon theme
 * Some rendering problems here and there (scrollbars, listviews, etc)
 * Crashes on quit sometimes

Most of the work was done by KapiX. I just wrote a few patches, a recipe and managed to build it using haikuporter with help from 3dEyes.

Some screenshots made by 3dEyes:

[3]LibreOffice_6_Elementary_Icons_Haiku

[4]LibreOffice_6_Calc_Haiku

[5]LibreOffice_6_Tango_Icons_Haiku

[6]LibreOffice_6_Draw_Haiku

[7]LibreOffice_6_Writer_Haiku

[8]LibreOffice_6_Impress_Haiku

[9]PulkoMandy 2018-06-06 08:31:14 UTC #2

Thanks to everyone involved for getting it running!

[10]SamuraiCrow 2018-06-06 08:41:02 UTC #3

Excellent!! I look forward to the updates!

[11]Diver 2018-06-06 12:22:12 UTC #4

New version with native look and feel is coming soon…

[12]image

[13]zittergie 2018-06-06 12:24:13 UTC #5

[14]BlueSky 2018-06-06 12:33:53 UTC #6

Wow…very impressive work, even if it is still a bit buggy [15]:wink:
Thanks a lot to everyone involved!

[16]Diver 2018-06-06 12:35:34 UTC #7

Most of the bugs are fixed too now.

[17]General_Edmund_Duke 2018-06-06 13:09:12 UTC #8

WOW! I haven`t expected to see it earlier than in incoming a few years! Good job!

[18]apgreimann 2018-06-06 17:41:07 UTC #9

Very exciting! Thanks to everyone who got this marvel running!

Just two questions: What minimum version is needed, and what repo in the Depot is this available in? Thanks!

[19]miqlas 2018-06-06 19:45:50 UTC #10

[20]apgreimann 2018-06-06 21:09:21 UTC #11

Thanks! I’ll try this out tonight! [21]:grin:

[22]frankps 2018-06-06 21:15:31 UTC #12

I’ve just installed latest 64 bit nightly build, but I get an error message when starting Libre Office. I’m missing libboost_locale.so.1.65.1

[23]cocobean 2018-06-06 22:19:16 UTC #14

Depending on when you got the package, you can either install the missing packages or:

pkgman update
pkgman uninstall libreoffice
pkgman install libreoffice

[24]Diver 2018-06-06 22:53:02 UTC #15

pkgman install boost165 should fix it. Will fix it later in the recipe…

[25]frankps 2018-06-07 02:47:39 UTC #16

Thank you all for some amazing work.

Now I need to find myself an old laptop that can run Haiku natively and start using it!

[26]Stacked_Lambda 2018-06-07 03:19:24 UTC #17

Excellent.

From the captions for the screen shots, this is LibreOffice 6.0. Correct?

I presume it is available in 32-bit and 64-bit variants?

When I have an opportunity for formal testing, I will assess how well files created/edited in LibreOffice are handled by MS Office. My current and prospective clients are using solely MS Office.

[27]Michael_V_Oliveira 2018-06-07 03:21:05 UTC #18

WOW!! Looks nice!!

Waiting for the native backend [28]:slight_smile:

[29]stippi 2018-06-07 12:07:16 UTC #19

Amazing! This screenshot looks quite awesome already. Is the look and feel due to updates to the Haiku look&feel in the Qt port?

[30]Diver 2018-06-07 12:22:25 UTC #20

Yes, LibreOffice uses its own GUI toolkit - VCL.

 Visual Components Library is responsible for the widgets (windowing, buttons, controls, file-pickers etc.) operating system abstraction, including basic rendering (e.g. the output device).

 VCL provides a graphical toolkit similar to gtk+, Qt, SWING etc.

VCL has several backends: GTK2, GTK3, Qt5 and KDE5 which is fairly new:
[31]https://github.com/LibreOffice/core/commits/master/vcl/unx/kde5.

Our Qt port also has BControlLook mapping, see:
[32]https://github.com/threedeyes/qthaikuplugins/commits/master/styles.

[33]stippi 2018-06-07 12:44:41 UTC #21

Thanks! What I meant was how is the difference between the first screenshots in the post itself and the screenshot from your comment explained? For example the scrollbars and drop-downs look native in your later screenshot. I thought the BControlLook-mapper already existed in the Qt port since a long time, I remember making changes to it myself. So if both screenshots use the same VCL backend, why does the second one look so much better?

[34]next page →

[35]Home [36]Categories [37]FAQ/Guidelines [38]Terms of Service [39]Privacy Policy

References

Visible links
1. https://discuss.haiku-os.org/u/Diver
2. https://depot.haiku-os.org/libreoffice
3. https://discuss.haiku-os.org/uploads/default/original/2X/0/0553680208d2f7e6e046e432c8d341ef2ebf18b0.jpg
4. https://discuss.haiku-os.org/uploads/default/original/2X/2/2a40fa54e75f0e9aa66a5fcca91c4302a6465f25.jpg
5. https://discuss.haiku-os.org/uploads/default/original/2X/1/1681dc6bb4be607d5c0a466b917e96d78a694c43.jpg
6. https://discuss.haiku-os.org/uploads/default/original/2X/6/60b5fdb84326f70e4820d9759894a6a8c6cf0317.jpg
7. https://discuss.haiku-os.org/uploads/default/original/2X/8/8a966a368cce966968e295373f3e127599636e8f.jpg
8. https://discuss.haiku-os.org/uploads/default/original/2X/e/ecc6b18f7b41f02fe88276c49b438757addfc4f5.jpg
9. https://discuss.haiku-os.org/u/PulkoMandy
10. https://discuss.haiku-os.org/u/SamuraiCrow
11. https://discuss.haiku-os.org/u/Diver
12. https://discuss.haiku-os.org/uploads/default/original/2X/b/bf620ae29673883b09bae7f350193c789b44d151.png
13. https://discuss.haiku-os.org/u/zittergie
14. https://discuss.haiku-os.org/u/BlueSky
16. https://discuss.haiku-os.org/u/Diver
17. https://discuss.haiku-os.org/u/General_Edmund_Duke
18. https://discuss.haiku-os.org/u/apgreimann
19. https://discuss.haiku-os.org/u/miqlas
20. https://discuss.haiku-os.org/u/apgreimann
22. https://discuss.haiku-os.org/u/frankps
23. https://discuss.haiku-os.org/u/cocobean
24. https://discuss.haiku-os.org/u/Diver
25. https://discuss.haiku-os.org/u/frankps
26. https://discuss.haiku-os.org/u/Stacked_Lambda
27. https://discuss.haiku-os.org/u/Michael_V_Oliveira
29. https://discuss.haiku-os.org/u/stippi
30. https://discuss.haiku-os.org/u/Diver
31. https://github.com/LibreOffice/core/commits/master/vcl/unx/kde5
32. https://github.com/threedeyes/qthaikuplugins/commits/master/styles
33. https://discuss.haiku-os.org/u/stippi
34. https://discuss.haiku-os.org/t/libreoffice-is-now-available-for-haiku/6917?page=2
35. https://discuss.haiku-os.org/
36. https://discuss.haiku-os.org/categories
37. https://discuss.haiku-os.org/guidelines
38. https://discuss.haiku-os.org/tos
39. https://discuss.haiku-os.org/privacy

HackerNewsBot debug: Calculated post rank: 86 - Loop: 103 - Rank min: 80 - Author rank: 28

...15 Pleromæ later...
Pleroma #1 slowly begins to deteriorate. Pleroma #2 has apparently made friends with #4. Pleromæ #3 to #8 mutated to add the well-awaited limit raise to the specific number 5058. A rationale as to why such number was selected is yet unknown, but to be found.

Before spawning Pleroma #17, I have fixed an outstanding bug with Pleroma #7 since inception - it refuses to federate out, whatsoever.
...

JVM Internals

Explains the internal architecture of the Java Virtual Machine (JVM) in simple terms using showing key components and how memory is updated during execution.

Article word count: 4956

HN Discussion: https://news.ycombinator.com/item?id=17271913

Posted by flying_sheep (karma: 60)

Post stats: Points: 120 - Comments: 10 - 2018-06-09T07:03:55Z

#HackerNews #internals #jvm

Article content:

This article explains the internal architecture of the Java Virtual Machine (JVM). The following diagram show the key internal components of a typical JVM that conforms to [1]The Java Virtual Machine Specification Java SE 7 Edition.

[2]internal architecture of Java Virtual Machine (JVM)

The components shown on this diagram are each explained below in two sections. [3]First section covers the components that are created for each thread and the [4]second section covers the components that are created independently of threads.

A thread is a thread of execution in a program. The JVM allows an application to have multiple threads of execution running concurrently. In the Hotspot JVM there is a direct mapping between a Java Thread and a native operating system Thread. After preparing all of the state for a Java thread such as thread-local storage, allocation buffers, synchronization objects, stacks and the program counter, the native thread is created. The native thread is reclaimed once the Java thread terminates. The operating system is therefore responsible for scheduling all threads and dispatching them to any available CPU. Once the native thread has initialized it invokes the run() method in the Java thread. When the run() method returns, uncaught exceptions are handled, then the native thread confirms if the JVM needs to be terminated as a result of the thread terminating (i.e. is it the last non-deamon thread). When the thread terminates all resources for both the native and Java thread are released.

JVM System Threads

If you use jconsole or any debugger it is possible to see there are numerous threads running in the background. These background threads run in addition to the main thread, which is created as part of invoking public static void main(String[]), and any threads created by the main thread. The main background system threads in the Hotspot JVM are:

VM thread

This thread waits for operations to appear that require the JVM to reach a safe-point. The reason these operations have to happen on a separate thread is because they all require the JVM to be at a safe point where modifications to the heap can not occur. The type of operations performed by this thread are "stop-the-world" garbage collections, thread stack dumps, thread suspension and biased locking revocation.

Periodic task thread

This thread is responsible for timer events (i.e. interrupts) that are used to schedule execution of periodic operations

GC threads

These threads support the different types of garbage collection activities that occur in the JVM

Compiler threads

These threads compile byte code to native code at runtime

Signal dispatcher thread

This thread receives signals sent to the JVM process and handle them inside the JVM by calling the appropriate JVM methods.

Per Thread

Each thread of execution has the following components:

Program Counter (PC)

Address of the current instruction (or opcode) unless it is native. If the current method is native then the PC is undefined. All CPUs have a PC, typically the PC is incremented after each instruction and therefore holds the address of the next instruction to be executed. The JVM uses the PC to keep track of where it is executing instructions, the PC will in fact be pointing at a memory address in the Method Area.

Stack

Each thread has its own stack that holds a frame for each method executing on that thread. The stack is a Last In First Out (LIFO) data structure, so the currently executing method is at the top of the stack. A new frame is created and added (pushed) to the top of stack for every method invocation. The frame is removed (popped) when the method returns normally or if an uncaught exception is thrown during the method invocation. The stack is not directly manipulated, except to push and pop frame objects, and therefore the frame objects may be allocated in the Heap and the memory does not need to be contiguous.

Native Stack

Not all JVMs support native methods, however, those that do typically create a per thread native method stack. If a JVM has been implemented using a C-linkage model for Java Native Invocation (JNI) then the native stack will be a C stack. In this case the order of arguments and return value will be identical in the native stack to typical C program. A native method can typically (depending on the JVM implementation) call back into the JVM and invoke a Java method. Such a native to Java invocation will occur on the stack (normal Java stack); the thread will leave the native stack and create a new frame on the stack (normal Java stack).

Stack Restrictions

A stack can be a dynamic or fixed size. If a thread requires a larger stack than allowed a StackOverflowError is thrown. If a thread requires a new frame and there isn’t enough memory to allocate it then an OutOfMemoryError is thrown.

Frame

A new frame is created and added (pushed) to the top of stack for every method invocation. The frame is removed (popped) when the method returns normally or if an uncaught exception is thrown during the method invocation. For more detail on exception handling [5]see the section on Exception Tables below.

Each frame contains:

 * Local variable array
 * Return value
 * Operand stack
 * Reference to runtime constant pool for class of the current method

The array of local variables contains all the variables used during the execution of the method, including a reference to this, all method parameters and other locally defined variables. For class methods (i.e. static methods) the method parameters start from zero, however, for instance method the zero slot is reserved for this.

A local variable can be:

 * boolean
 * byte
 * char
 * long
 * short
 * int
 * float
 * double
 * reference
 * returnAddress

All types take a single slot in the local variable array except long and double which both take two consecutive slots because these types are double width (64-bit instead of 32-bit).

Operand Stack

The operand stack is used during the execution of byte code instructions in a similar way that general-purpose registers are used in a native CPU. Most JVM byte code spends its time manipulating the operand stack by pushing, popping, duplicating, swapping, or executing operations that produce or consume values. Therefore, instructions that move values between the array of local variables and the operand stack are very frequent in byte code. For example, a simple variable initialization results in two byte codes that interact with the operand stack.

int i;

Gets compiled to the following byte code:

0: iconst_0 // Push 0 to top of the operand stack 1: istore_1 // Pop value from top of operand stack and store as local variable 1

For more detail explaining interactions between the local variables array, operand stack and run time constant pool [6]see the section on Class File Structure below.

Each frame contains a reference to the runtime constant pool. The reference points to the constant pool for the class of the method being executed for that frame. This reference helps to support dynamic linking.

C/C++ code is typically compiled to an object file then multiple object files are linked together to product a usable artifact such as an executable or dll. During the linking phase symbolic references in each object file are replaced with an actual memory address relative to the final executable. In Java this linking phase is done dynamically at runtime.

When a Java class is compiled, all references to variables and methods are stored in the classʼs constant pool as a symbolic reference. A symbolic reference is a logical reference not a reference that actually points to a physical memory location. The JVM implementation can choose when to resolve symbolic references, this can happen when the class file is verified, after being loaded, called eager or static resolution, instead this can happen when the symbolic reference is used for the first time called lazy or late resolution. However the JVM has to behave as if the resolution occurred when each reference is first used and throw any resolution errors at this point. Binding is the process of the field, method or class identified by the symbolic reference being replaced by a direct reference, this only happens once because the symbolic reference is completely replaced. If the symbolic reference refers to a class that has not yet been resolved then this class will be loaded. Each direct reference is stored as an offset against the storage structure associated with the runtime location of the variable or method.

Heap

The Heap is used to allocate class instances and arrays at runtime. Arrays and objects can never be stored on the stack because a frame is not designed to change in size after it has been created. The frame only stores references that point to objects or arrays on the heap. Unlike primitive variables and references in the local variable array (in each frame) objects are always stored on the heap so they are not removed when a method ends. Instead objects are only removed by the garbage collector.

To support garbage collection the heap is divided into three sections:

 * Young Generation

      * Often split between Eden and Survivor

 * Old Generation (also called Tenured Generation)
 * Permanent Generation

Objects and Arrays are never explicitly de-allocated instead the garbage collector automatically reclaims them.

Typically this works as follows:

 1. New objects and arrays are created into the young generation
 2. Minor garbage collection will operate in the young generation. Objects, that are still alive, will be moved from the eden space to the survivor space.
 3. Major garbage collection, which typically causes the application threads to pause, will move objects between generations. Objects, that are still alive, will be moved from the young generation to the old (tenured) generation.
 4. The permanent generation is collected every time the old generation is collected. They are both collected when either becomes full.

Objects that are logically considered as part of the JVM mechanics are not created on the Heap.

The non-heap memory includes:

 * Permanent Generation that contains

      * the method area
      * interned strings

 * Code Cache used for compilation and storage of methods that have been compiled to native code by the JIT compiler

Java byte code is interpreted however this is not as fast as directly executing native code on the JVM’s host CPU. To improve performance the Oracle Hotspot VM looks for “hot” areas of byte code that are executed regularly and compiles these to native code. The native code is then stored in the code cache in non-heap memory. In this way the Hotspot VM tries to choose the most appropriate way to trade-off the extra time it takes to compile code verses the extra time it take to execute interpreted code.

Method Area

The method area stores per-class information such as:

 * Classloader Reference
 * Run Time Constant Pool

      * Numeric constants
      * Field references
      * Method References
      * Attributes

 * Field data

      * Per field

           * Name
           * Type
           * Modifiers
           * Attributes

 * Method data

      * Per method

           * Name
           * Return Type
           * Parameter Types (in order)
           * Modifiers
           * Attributes

 * Method code

      * Per method

           * Bytecodes
           * Operand stack size
           * Local variable size
           * Local variable table
           * Exception table

                * Per exception handler

                     * Start point
                     * End point
                     * PC offset for handler code
                     * Constant pool index for exception class being caught

All threads share the same method area, so access to the method area data and the process of dynamic linking must be thread safe. If two threads attempt to access a field or method on a class that has not yet been loaded it must only be loaded once and both threads must not continue execution until it has been loaded.

Class File Structure

A compiled class file consists of the following structure:

ClassFile { u4 magic; u2 minor_version; u2 major_version; u2 constant_pool_count; cp_info contant_pool[constant_pool_count – 1]; u2 access_flags; u2 this_class; u2 super_class; u2 interfaces_count; u2 interfaces[interfaces_count]; u2 fields_count; field_info fields[fields_count]; u2 methods_count; method_info methods[methods_count]; u2 attributes_count; attribute_info attributes[attributes_count];
}

magic, minor_version, major_version

specifies information about the version of the class and the version of the JDK this class was compiled for.

access_flags

provides the list of modifiers for this class.

this_class

index into the constant_pool providing the fully qualified name of this class i.e. org/jamesdbloom/foo/Bar

super_class

index into the constant_pool providing a symbolic reference to the super class i.e. java/lang/Object

interfaces

array of indexes into the constant_pool providing a symbolic references to all interfaces that have been implemented.

fields

array of indexes into the constant_pool giving a complete description of each field.

methods

array of indexes into the constant_pool giving a complete description of each method signature, if the method is not abstract or native then the bytecode is also present.

attributes

array of different value that provide additional information about the class including any annotations with RetentionPolicy.CLASS or RetentionPolicy.RUNTIME

It is possible to view the byte code in a compiled Java class by using the javap command.

If you compile the following simple class:

package org.jvminternals; public class SimpleClass { public void sayHello() { System.out.println("Hello"); } }

Then you get the following output if you run:

javap -v -p -s -sysinfo -constants classes/org/jvminternals/SimpleClass.class

public class org.jvminternals.SimpleClass SourceFile: "SimpleClass.java" minor version: 0 major version: 51 flags: ACC_PUBLIC, ACC_SUPER
Constant pool: #1 = Methodref #6.#17 // java/lang/Object."":()V #2 = Fieldref #18.#19 // java/lang/System.out:Ljava/io/PrintStream; #3 = String #20 // "Hello" #4 = Methodref #21.#22 // java/io/PrintStream.println:(Ljava/lang/String;)V #5 = Class #23 // org/jvminternals/SimpleClass #6 = Class #24 // java/lang/Object #7 = Utf8 #8 = Utf8 ()V #9 = Utf8 Code #10 = Utf8 LineNumberTable #11 = Utf8 LocalVariableTable #12 = Utf8 this #13 = Utf8 Lorg/jvminternals/SimpleClass; #14 = Utf8 sayHello #15 = Utf8 SourceFile #16 = Utf8 SimpleClass.java #17 = NameAndType #7:#8 // "":()V #18 = Class #25 // java/lang/System #19 = NameAndType #26:#27 // out:Ljava/io/PrintStream; #20 = Utf8 Hello #21 = Class #28 // java/io/PrintStream #22 = NameAndType #29:#30 // println:(Ljava/lang/String;)V #23 = Utf8 org/jvminternals/SimpleClass #24 = Utf8 java/lang/Object #25 = Utf8 java/lang/System #26 = Utf8 out #27 = Utf8 Ljava/io/PrintStream; #28 = Utf8 java/io/PrintStream #29 = Utf8 println #30 = Utf8 (Ljava/lang/String;)V
{ public org.jvminternals.SimpleClass(); Signature: ()V flags: ACC_PUBLIC Code: stack=1, locals=1, args_size=1 0: aload_0 1: invokespecial #1 // Method java/lang/Object."":()V 4: return LineNumberTable: line 3: 0 LocalVariableTable: Start Length Slot Name Signature 0 5 0 this Lorg/jvminternals/SimpleClass; public void sayHello(); Signature: ()V flags: ACC_PUBLIC Code: stack=2, locals=1, args_size=1 0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream; 3: ldc #3 // String "Hello" 5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 8: return LineNumberTable: line 6: 0 line 7: 8 LocalVariableTable: Start Length Slot Name Signature 0 9 0 this Lorg/jvminternals/SimpleClass;
}

This class file shows three main sections the constant pool, the constructor and the sayHello method.

 * Constant Pool – this provides the same information that a symbol table typically provides and is [7]described in more detail below.
 * Methods – each containing four areas:

      * signature and access flags
      * byte code
      * LineNumberTable – this provides information to a debugger to indicate which line corresponds to which byte code instruction, for example line 6 in the Java code corresponds to byte code 0 in the sayHello method and line 7 corresponds to byte code 8.
      * LocalVariableTable – this lists all local variables provided in the frame, in both examples the only local variable is this.

The following byte code operands are used in this class file

aload_0

This opcode is one of a group of opcodes with the format aload_. They all load an object reference into the operand stack. The refers to the location in the local variable array that is being accessed but can only be 0, 1, 2 or 3. There are other similar opcodes for loading values that are not an object reference iload_, lload_, float_ and dload_ where i is for int, l is for long, f is for float and d is for double. Local variables with an index higher than 3 can be loaded using iload, lload, float, dload and aload. These opcodes all take a single operand that specifies the index of local variable to load.

ldc

This opcode is used to push a constant from the run time constant pool into the operand stack.

getstatic

This opcode is used to push a static value from a static field listed in the run time constant pool into the operand stack.

invokespecial, invokevirtual

These opcodes are in a group of opcodes that invoke methods these are invokedynamic, invokeinterface, invokespecial, invokestatic, invokevirtual. In this class file invokespecial and invokevirutal are both used the difference between these is that invokevirutal invokes a method based on the class of the object. The invokespecial instruction is used to invoke instance initialization methods as well as private methods and methods of a superclass of the current class.

return

This opcode is in a group of opcodes ireturn, lreturn, freturn, dreturn, areturn and return. Each of these opcodes are a typed return statement that returns a different type where i is for int, l is for long, f is for float, d is for double and a is for an object reference. The opcode with no leading type letter return only returns void.

As in any typical byte code the majority of the operands interact with the local variables, operand stack and run time constant pool as follows.

The constructor has two instructions first this is pushed onto the operand stack, next the constructor for the super class is invoked which consumes the value off this and therefore pops it off the operand stack.

[8]local variables, operand stack and run time constant pool changes when invoking a static method in Java Virtual Machine (JVM)

The sayHello() method is more complex as it has to resolve symbolic references to actual references using the run time constant pool, [9]as explained in more detail above. The first operand getstatic is used to push a reference to the static field out of the System class on to the operand stack. The next operand ldc pushes the string "Hello" onto the operand stack. The final operand invokevirtual invokes the println method of System.out which pops "Hello" off the operand stack as an argument and creates a new frame for the current thread.

[10]local variables, operand stack and run time constant pool changes when calling System.out in Java Virtual Machine (JVM)

The JVM starts up by loading an initial class using the bootstrap classloader. The class is then linked and initialized before public static void main(String[]) is invoked. The execution of this method will in turn drive the loading, linking and initialization of additional classes and interfaces as required.

Loading is the process of finding the class file that represents the class or interface type with a particular name and reading it into a byte array. Next the bytes are parsed to confirm they represent a Class object and have the correct major and minor versions. Any class or interface named as a direct superclass is also loaded. Once this is completed a class or interface object is created from the binary representation.

Linking is the process of taking a class or interface verifying and preparing the type and its direct superclass and superinterfaces. Linking consists of three steps verifying, preparing and optionally resolving.

Verifying is the process of confirming the class or interface representation is structurally correct and obeys the semantic requirements of the Java programming language and JVM, for example the following checks are performed:

 1. consistent and correctly formatted symbol table
 2. final methods / classes not overridden
 3. methods respect access control keywords
 4. methods have correct number and type of parameters
 5. bytecode doesnʼt manipulate stack incorrectly
 6. variables are initialized before being read
 7. variables are a value of the correct type

Performing these checks during the verifying stages means these checks do not need to be performed at runtime. Verification during linking slows down class loading however it avoids the need to perform these checks multiple when executing the bytecode.

Preparing involves allocation of memory for static storage and any data structures used by the JVM such as method tables. Static fields are created and initialized to their default values, however, no initializers or code is executed at this stage as that happens as part of initialization.

Resolving is an optional stage which involves checking symbolic references by loading the referenced classes or interfaces and checking the references are correct. If this does not take place at this point the resolution of symbolic references can be deferred until just prior to their use by a byte code instruction.

Initialization of a class or interface consists of executing the class or interface initialization method

[11]class loading, linking and initialization in the Java Virtual Machine (JVM)

In the JVM there are multiple classloaders with different roles. Each classloader delegates to its parent classloader (that loaded it) except the bootstrap classloader which is the top classloader.

Bootstrap Classloader is usually implemented as native code because it is instantiated very early as the JVM is loaded. The bootstrap classloader is responsible for loading the basic Java APIs, including for example rt.jar. It only loads classes found on the boot classpath which have a higher level of trust; as a result it skips much of the validation that gets done for normal classes.

Extension Classloader loads classes from standard Java extension APIs such as security extension functions.

System Classloader is the default application classloader, which loads application classes from the classpath.

User Defined Classloaders can alternatively be used to load application classes. A user defined classloader is used for a number of special reasons including run time reloading of classes or separation between different groups of loaded classes typically required by web servers such as Tomcat.

[12]classloader hierarchy in the Java Virtual Machine (JVM)

Faster Class Loading

A feature called Class Data Sharing (CDS) was introduce in HotSpot JMV from version 5.0. During the installation process of the JVM the installer loads a set of key JVM classes, such as rt.jar, into a memory-mapped shared archive. CDS reduces the time it takes to load these classes improving JVM start-up speed and allows these classes to be shared between different instances of the JVM reducing the memory footprint.

Where Is The Method Area

[13]The Java Virtual Machine Specification Java SE 7 Edition clearly states: “Although the method area is logically part of the heap, simple implementations may choose not to either garbage collect or compact it.” In contradiction to this jconsole for the Oracle JVM shows the method area (and code cache) as being non-heap. The [14]OpenJDK code shows that the CodeCache is a separate field of the VM to the ObjectHeap.

All classes that are loaded contain a reference to the classloader that loaded them. In turn the classloader also contains a reference to all classes that it has loaded.

Run Time Constant Pool

The JVM maintains a per-type constant pool, a run time data structure that is similar to a symbol table although it contains more data. Byte codes in Java require data, often this data is too large to store directly in the byte codes, instead it is stored in the constant pool and the byte code contains a reference to the constant pool. The run time constant pool is used in dynamic linking [15]as described above

Several types of data is stored in the constant pool including

 * numeric literals
 * string literals
 * class references
 * field references
 * method references

For example the following code:

Object foo = new Object();

Would be written in byte code as follows:

0: new #2 // Class java/lang/Object 1: dup 2: invokespecial #3 // Method java/ lang/Object ""( ) V

The new opcode (operand code) is followed by the #2 operand. This operand is an index into the constant pool and therefore is referencing the second entry in the constant pool. The second entry is a class reference, this entry in turn references another entry in the constant pool containing the name of the class as a constant UTF8 string with the value // Class java/lang/Object. This symbolic link can then be used to lookup the class for java.lang.Object. The new opcode creates a class instance and initializes its variables. A reference to the new class instance is then added to the operand stack. The dup opcode then creates an extra copy of the top reference on the operand stack and adds this to the top of the operand stack. Finally an instance initialization method is called on line 2 by invokespecial. This operand also contains a reference to the constant pool. The initialization method consumes (pops) the top reference off the operand pool as an argument to the method. At the end there is one reference to the new object that has been both created and initialized.

If you compile the following simple class:

package org.jvminternals; public class SimpleClass { public void sayHello() { System.out.println("Hello"); } }

The constant pool in the generated class file would look like:

Constant pool: #1 = Methodref #6.#17 // java/lang/Object."":()V #2 = Fieldref #18.#19 // java/lang/System.out:Ljava/io/PrintStream; #3 = String #20 // "Hello" #4 = Methodref #21.#22 // java/io/PrintStream.println:(Ljava/lang/String;)V #5 = Class #23 // org/jvminternals/SimpleClass #6 = Class #24 // java/lang/Object #7 = Utf8 #8 = Utf8 ()V #9 = Utf8 Code #10 = Utf8 LineNumberTable #11 = Utf8 LocalVariableTable #12 = Utf8 this #13 = Utf8 Lorg/jvminternals/SimpleClass; #14 = Utf8 sayHello #15 = Utf8 SourceFile #16 = Utf8 SimpleClass.java #17 = NameAndType #7:#8 // "":()V #18 = Class #25 // java/lang/System #19 = NameAndType #26:#27 // out:Ljava/io/PrintStream; #20 = Utf8 Hello #21 = Class #28 // java/io/PrintStream #22 = NameAndType #29:#30 // println:(Ljava/lang/String;)V #23 = Utf8 org/jvminternals/SimpleClass #24 = Utf8 java/lang/Object #25 = Utf8 java/lang/System #26 = Utf8 out #27 = Utf8 Ljava/io/PrintStream; #28 = Utf8 java/io/PrintStream #29 = Utf8 println #30 = Utf8 (Ljava/lang/String;)V

The constant pool contains the following types:

Integer

A 4 byte int constant

Long

An 8 byte long constant

Float

A 4 byte float constant

Double

A 8 byte double constant

String

A String constant that points at another Utf8 entry in the constant pool which contains the actual bytes

Utf8

A stream of bytes representing a Utf8 encoded sequence of characters

Class

A Class constant that points at another Utf8 entry in the constant pool which contains the fully qualified class name in the internal JVM format (this is used by the [16]dynamic linking process)

NameAndType

A colon separated pair of values each pointing at other entries in the constant pool. The first value (before the colon) points at a Utf8 string entry that is the method or field name. The second value points at a Utf8 entry that represents the type, in the case of a field this is the fully qualified class name, in the case of a method this is a list of fully qualified class names one per parameter.

Fieldref, Methodref, InterfaceMethodref

A dot separated pair of values each pointing at other entries in the constant pool. The first value (before the dot) points at a Class entry. The second value points at a NameAndType entry.

Exception Table

The exception table stores per-exception handler information such as:

 * Start point
 * End point
 * PC offset for handler code
 * Constant pool index for exception class being caught

If a method has defined a try-catch or a try-finally exception handler then an Exception Table will be created. This contains information for each exception handler or finally block including the range over which the handler applies, what type of exception is being handled and where the handler code is.

When an exception is thrown the JVM looks for a matching handler in the current method, if none is found the method ends abruptly popping the current stack frame and the exception is re-thrown in the calling method (the new current frame). If no exception handler is found before all frames have been popped then the thread is terminated. This can also cause the JVM itself to terminate if the exception is thrown in the last non-daemon thread, for example if the thread is the main thread.

Finally exception handlers match all types of exceptions and so always execute whenever an exception is thrown. In the case when no exception is thrown a finally block is still executed at the end of a method, this is achieved by jumping to the finally handler code immediately before the return statement is executed.

Symbol Table

In addition to per-type run-time constant pools the Hotspot JVM has a symbol table held in the permanent generation. The symbol table is a Hashtable mapping symbol pointers to symbols (i.e. Hashtable) and includes a pointer to all symbols including those held in run time constant pools in each class.

Reference counting is used to control when a symbol is removed from the symbol table. For example when a class is unloaded the reference count of all symbols held in its run time constant pool are decremented. When the reference count of a symbol in the the symbol table goes to zero then the symbol table knows that symbol is not being referenced anymore and the symbol is unloaded from the symbol table. For both the symbol table and the string table (see below) all entries are held in a canonicalized form to improve efficiency and ensure each entry only appears once.

Interned Strings (String Table)

The Java Language Specification requires that identical string literals, that contain the same sequence of Unicode code points, must refer to the same instance of String. In addition if String.intern() is called on an instance of String a reference must be returned that would be identical to the reference return if the string was a literal. The following therefore holds true:

("j" + "v" + "m").intern() == "jvm"

In the Hotspot JVM interned string are held in the string table, which is a Hashtable mapping object pointers to symbols (i.e. Hashtable), and is held in the permanent generation. For both the symbol table (see above) and the string table all entries are held in a canonicalized form to improve efficiency and ensure each entry only appears once.

String literals are automatically interned by the compiler and added into the symbol table when the class is loaded. In addition instances of the String class can be explicitly interned by calling String.intern(). When String.intern() is called, if the symbol table already contains the string then a reference to this is returned, if not the string is added to the string table and its reference is returned.

References

Visible links
1. http://www.amazon.co.uk/Virtual-Machine-Specification-Edition-Series/dp/0133260445
2. http://blog.jamesdbloom.com/images_2013_11_17_17_56/JVM_Internal_Architecture.png
3. http://blog.jamesdbloom.com/JVMInternals.html#threads
4. http://blog.jamesdbloom.com/JVMInternals.html#shared_between_threads
5. http://blog.jamesdbloom.com/JVMInternals.html#exception_table
6. http://blog.jamesdbloom.com/JVMInternals.html#class_file_structure
7. http://blog.jamesdbloom.com/JVMInternals.html#constant_pool
8. http://blog.jamesdbloom.com/images_2013_11_17_17_56/bytecode_explanation_SimpleClass.png
9. http://blog.jamesdbloom.com/JVMInternals.html#dynamic_linking
10. http://blog.jamesdbloom.com/images_2013_11_17_17_56/bytecode_explanation_sayHello.png
11. http://blog.jamesdbloom.com/images_2013_11_17_17_56/Class_Loading_Linking_Initializing.png
12. http://blog.jamesdbloom.com/images_2013_11_17_17_56/class_loader_hierarchy.png
13. http://www.amazon.co.uk/Virtual-Machine-Specification-Edition-Series/dp/0133260445
14. http://openjdk.java.net/
15. http://blog.jamesdbloom.com/JVMInternals.html#dynamic_linking
16. http://blog.jamesdbloom.com/JVMInternals.html#dynamic_linking

HackerNewsBot debug: Calculated post rank: 83 - Loop: 58 - Rank min: 80 - Author rank: 46

Shutting Down Forum (GDPR)

In case anyone is interested, this basically described what has been happening to me: https://jacquesmattheij.com/so-your-start-up-receive-the-nightmare-gdpr-letter The sad thing is that one email…

Article word count: 806

HN Discussion: https://news.ycombinator.com/item?id=17208065

Posted by spacebearmakes (karma: 52)

Post stats: Points: 90 - Comments: 128 - 2018-06-01T17:54:20Z

#HackerNews #down #forum #gdpr #shutting

Article content:

[1]bradrydzewski 2018-05-28 19:23:48 UTC #1

Dear Drone Community,

Drone has begun receiving formal GDPR compliance requests. As an open source project I do not have the time or resources to process these requests, nor am I willing to pay for legal counsel out-of-pocket to advise on such matters and draft formal policy documentation.

I have therefore decided to shutdown this forum effective July 1 and have disabled new account creation effective immediately. We will transition this mailing list to [2]/r/droneci which is better equipped to ensure ongoing compliance with data privacy regulations. Please understand that I am not making a political statement for or against GDPR. I simply believe this is the easiest, most cost-effective path toward compliance.

Please note that we will continue to offer Enterprise Support via our Slack channel.

[3]bradrydzewski 2018-05-28 19:24:08 UTC #2

[4]bradrydzewski 2018-05-29 01:04:50 UTC #4

I do appreciate the links. The gdpr documentation is quite long and I lack the domain expertise to read and comprehend the document in full. Perhaps this is cultural, since the United States is a very litigious society, but I would not feel comfortable accepting liability for gdpr compliance without consulting an attorney. It is also unclear how I am expected to respond to DPA execution requests (what the hell is a DPA request?), which I have already received, and what penalties I could face if I fail to provide a sufficient response. Overall, it just seems like outsourcing to StackOverflow or Google Groups makes more sense. This way I can focus my time on making Drone better, as opposed to becoming a legal expert [5]:slight_smile:

[6]laszlocph 2018-05-29 12:18:04 UTC #5

The sad part is losing this knowledgebase completely.

Github issues have links to the old forum, then there was the Gitter period, and now losing this forum. Doesn’t send a good message [7]:frowning:

[8]bradrydzewski 2018-05-29 14:32:44 UTC #6

The knowledge base can be archived, and Stack Overflow will still provide an avenue to share knowledge and receive support from volunteers. The great thing about Stack Overflow is that there is no administration required, and ownership and administration is much more decentralized. Stack Overflow also supports a feature called [9]Stack Overflow Documentation to which the current knowledge base may be transferred.

[10]gboddin 2018-05-29 16:02:15 UTC #7

Clicks on documentation

We have shut down
Stack Overflow Documentation.

Documentation was our attempt at improving existing reference materials by focusing on examples. The beta ran from July 21st, 2016 until August 8th, 2017. For more details on why we ended it, please see our post on meta. Thank you to everyone that participated. As always, the content contributed by our community is available under CC-BY-SA: download the archive.

[11]@bradrydzewski maybe just transfer ownership ^^

[12]bradrydzewski 2018-05-30 06:56:11 UTC #8

Unfortunately I am told I may not permitted to transfer ownership. The Discourse software collects some personally identifiable and sensitive data (username, email, IP and github token for oauth login) and I do not have authorization to transfer ownership of this data to a third party. Such a transfer could be considered a violation of GDPR without having consent.

[13]ogarcia 2018-05-30 07:10:07 UTC #9

Why not do a Subreddit? It works like discourse and can have moderators.

[14]cedk 2018-05-30 10:23:19 UTC #10

bradrydzewski:

 I may not permitted to transfer ownership

But maybe you may “delegate” the operational to a “sub-contractor” who will take the responsibilities.

[15]bradrydzewski 2018-05-30 15:06:42 UTC #11

 But maybe you may “delegate” the operational to a “sub-contractor” who will take the responsibilities

I like the creative thinking [16]:slight_smile: Unfortunately even if I delegate operations I would still legally own the data, and would ultimately be financially liable for violations. Even if there were some loophole, I would need to consult my attorney to further advise and draw up agreements, which at a rate of $ 900 / hour could still be very expensive for me.

I think the best option is to move the forum to reddit or google groups as suggested by [17]@ogarcia.

[18]bradrydzewski 2018-05-30 16:44:16 UTC #12

[19]bradrydzewski 2018-05-31 18:58:42 UTC #13

In case anyone is interested, this basically described what has been happening to me:
[20]https://jacquesmattheij.com/so-your-start-up-receive-the-nightmare-gdpr-letter

The sad thing is that one email came from the co-founder of a Startup out of Germany. I cannot believe a startup founder would troll an open source project like this. It is very sad that people are using grpd, something that could provide a real social good, as a means to troll people.

The irony is not lost on me that I am now sending my community to Reddit, which is going to more actively collect and analyze data and browsing habits and serve people ads. Note that this is not a criticism of Reddit; I am very happy they are able to provide this service.

Anyway, I digress …

[21]Home [22]Categories [23]FAQ/Guidelines [24]Terms of Service [25]Privacy Policy

References

Visible links
1. https://discourse.drone.io/u/bradrydzewski
2. https://www.reddit.com/r/droneci
3. https://discourse.drone.io/u/bradrydzewski
4. https://discourse.drone.io/u/bradrydzewski
6. https://discourse.drone.io/u/laszlocph
8. https://discourse.drone.io/u/bradrydzewski
9. https://stackoverflow.com/documentation
10. https://discourse.drone.io/u/gboddin
11. https://discourse.drone.io/u/bradrydzewski
12. https://discourse.drone.io/u/bradrydzewski
13. https://discourse.drone.io/u/ogarcia
14. https://discourse.drone.io/u/cedk
15. https://discourse.drone.io/u/bradrydzewski
17. https://discourse.drone.io/u/ogarcia
18. https://discourse.drone.io/u/bradrydzewski
19. https://discourse.drone.io/u/bradrydzewski
20. https://jacquesmattheij.com/so-your-start-up-receive-the-nightmare-gdpr-letter
21. https://discourse.drone.io/
22. https://discourse.drone.io/categories
23. https://discourse.drone.io/guidelines
24. https://discourse.drone.io/tos
25. https://discourse.drone.io/privacy

HackerNewsBot debug: Calculated post rank: 102 - Loop: 290 - Rank min: 100 - Author rank: 104

@simba Clarification: They new laws were introduced in Norway specifically, after the Utøya massacre carried out by Anders Breivik. Norway is a bit of an odd man out in Europe. We are #8 in gun ownership in the world, with 31 guns per 100 residents, but talk of guns is almost completely absent in the public space. There's an equivalent to the NRA but it doesn't seem to have much sway, perhaps because guns aren't a part of the national identity.

If there's one tiefling babe I will never get sick of drawing, it's definitely Lorafaen. This lovely lady is for you @JoshuaDean19@twitter.com - I do hope you enjoy!

✏️ko-fi #8 | https://t.co/znPX39yhTu https://t.co/8qZBRcQALR

https://twitter.com/sylessae/status/994294400099520514

https://mastodon.social/media/-isW4FsT9gdNBgcnBhg so jervis tetch is wearing this outfit in batman allstars #8 and I had to draw it it's too dapper

Spaceship Landing - 8tel Ride...

off of Spaceship Landing 12”x2 (red translucent vinyl) on World In Sound (2005)

#spaceshiplanding #spaceship #landing #8 #ride #worldinsound #2012 #audio #animatedgif #psychedelicrock

@aldersprig Cal Story #8

Don Marti: Predictions for 2018

Bitcoin to the moooon: The futures market is starting up, so here
comes a bunch more day trader action. More important, think about all
the bucket shops (I even saw an "invest in Bitcoin without owning
Bitcoin" ad on public transit in London), legit financial firms,
Libertarian true believers, and coins lost forever because of human
error. Central bankers had better keep an eye on Bitcoin, though. Last
recession we saw that printing money doesn't work as well as it used to,
because it ends up in the hands of rich people who, instead of priming
economic pumps with it, just drive up the prices of assets. I would
predict "Entire Round of Quantitative Easing Gets Invested in Bitcoin
Without Creating a Single New Job" but I'm saving that one for 2019.
Central banks will need to innovate. Federal Reserve car crushers?
Relieve medical deby by letting the UK operate NHS clinics at their
consulates in the USA, and we trade them US green cards for visas that
allow US citizens to get treated there? And—this is a brilliant quality
of Bitcoin that I recognized too late—there is no bad news that could
credibly hurt the value of a purely speculative asset.

The lesson for regular people here is not so much what to do with
Bitcoin, but remember to keep putting some well-considered time into
actions that you predict have unlikely but large and favorable outcomes.
Must remember to do more of this.

High-profile Bitcoin kidnapping in the USA ends in tragedy:
Kidnappers underestimate the amount of Bitcoin actually available to
change hands, ask for more than the victim's family (or fans? a
crowdsourced kidnapping of a celebrity is now a possibility) can raise
in time. Huge news but not big enough to slow down something that the
finance scene has already committed to.

Tech industry reputation problems hit open source. California
Internet douchebags talk like a positive social movement but act like
East Coast vampire squid—and people are finally not so much letting
them define the terms of the
conversation.
The real Internet economy is moving to a three-class system: plutocrats,
well-paid brogrammers with Aeron chairs, free snacks and good health
insurance, and everyone else in the algorithmically-managed precariat.
So far, people are more concerned about the big social and surveillance
marketing companies, but open source has some of the same issues. Just
as it was widely considered silly for people to call Facebook users "the
Facebook community" in 2017, some of the "community" talk about open
source will be questioned in 2018. Who's working for who, and who's
vulnerable to the risks of doing work that someone else extracts the
value of? College athletes are ahead of the open source scene on this
one.

Adfraud becomes a significant problem for end users: Powerful
botnets in data centers drove the pivot to
video. Now
that video adfraud is well-known, more of the fraud hackers will move to
attribution fraud. This ties in to adtech consolidation, too. Google is
better at beating simple to midrange fraud than the rest of the
Lumascape, so the steady progress towards a two-logo Lumascape means
fewer opportunities for bots in data centers.

Attribution fraud is nastier than servers-talking-to-servers fraud,
since it usually depends on having fraudulent and legit client software
on the same system—legit to be used for a human purchase, fraudulent to
"serve the ad" that takes credit for it. Unlike botnets that can run in
data centers, attribution fraud comes home with you. Yeech. Browsers and
privacy tools will need to level up from blocking relatively simple
Lumascape trackers to blocking cleverer, more aggressive attribution
fraud scripts.

Wannabe fascists keep control of the US Congress, because your
Marketing budget: "Dark" social campaigns (both ads and fake "organic"
activity) are still a thing. In the USA, voter suppression and
gerrymandering have been cleverly enough done that social manipulation
can still make a difference, and it will.

In the long run, dark social will get filtered out by habits,
technology, norms, and regulation—like junk fax and email spam before
it—but we don't have a "long run" between now and November 2018. The
only people who could make an impact on dark social now are the legit
advertisers who don't want their brands associated with this stuff. And
right now the expectations to advertise on the major social sites are
stronger than anybody's ability to get an edgy, controversial "let's not
SPONSOR ACTUAL F-----G NAZIS" plan through the 2018 marketing budget
process.

Yes, the idea of not spending marketing money on supporting
nationalist extremist forums is new and different now. What a year.

Bonus links

These Publishers Bought Millions Of Website Visits They Later Found Out
Were
Fraudulent

No boundaries for user identities: Web trackers exploit browser login
managers

Best of 2017 #8: The World's Most Expensive Clown
Show

My Internet Mea
Culpa

2017 Was the Year I Learned About My White
Privilege

With the people, not just of the
people

When Will Facebook Take Hate
Seriously?

Using Headless Mode in Firefox – Mozilla Hacks : the Web developer
blog

Why Chuck E. Cheese’s Has a Corporate Policy About Destroying Its
Mascot’s
Head

Dozens of Companies Are Using Facebook to Exclude Older Workers From
Job
Ads

How Facebook’s Political Unit Enables the Dark Art of Digital
Propaganda

https://blog.zgp.org/predictions-for-2018/

#botpost via feedDiasp*