public sealed class World
{
    ...
    private hkpWorld physicsWorld;
    ...
    
    public World()
    {
        //initialize world's physics and geometry with default values
        setupWorld(defaultGravity, defaultSize, defaultBorderBehaviour);
    }

    ...
    public hkpWorld getWorld()
    {
        //Yellow!!!
        //I'm Rajesh, I got Phd in India and now I'm going to fix one bug!
        
        hkpWorldCinfo worldInfo = new...;
        //let's change gravity from 9.8f to 10 because...
        worldInfo.m_gravity = 10;
        physicsWorld = new hkpWorld(worldInfo);
        ...
        //Hello, I'm mapnik and I see this code
        //FUUUUUUCK!!!
        return physicsWorld;
    }
    ...
}

class World {
public:
    World(){
        //initialize world's physics and geometry with default values
        setupWorld(defaultGravity, defaultSize, defaultBorderBehaviour);
    }
    ~World();

    //No Radjesh you can't :)))            
    hkpWorld*    getWorld() const { return physicsWorld; };
    ...

private:
    ...
    hkpWorld *        physicsWorld;
    ...
};

Если серьзно, то начиная с шестого шарпа очевидно поменялся подход к отбору фич.
Классика "дизайним очередной big thing и вылизываем всё, что с ним связано" никуда не делась.
Но помимо неё в язык по мере возможности добавляется мелочёвка, которая почти не влияет на public API и которая не особенно нужна в энтерпрайзе (серьёзно, если в коде такой баррдак, что даже приватные методы использовать небезопасно, ну сделай ты рефакторинг!).

Зато эта мелочёвка будет полезна для всяких скриптов/однодневных поделок и прочего write-only кода.
Это ни хорошо, ни плохо, просто последствия попытки пролезть в мобильную нищу и в нишу инди-сайтов.

class World {
public:
    World(){
        //initialize world's physics and geometry with default values
        setupWorld(defaultGravity, defaultSize, defaultBorderBehaviour);
    }
    ~World();

    //No Radjesh you can't :)))            
    hkpWorld* getWorld() const
    {
        //Yellow!!!
        //I'm Rajesh, I got Phd in India and now I'm going to fix one bug!
        
        hkpWorldCinfo worldInfo = new...;
        //let's change gravity from 9.8f to 10 because...
        worldInfo.m_gravity = 10;
        auto myRajeshphysicsWorld = new hkpWorld(worldInfo);
        ...
        //Hello, I'm mapnik and I see this code
        //FUUUUUUCK!!!
        return myRajeshphysicsWorld;
    };
    ...

private:
    ...
    hkpWorld *        physicsWorld;
    ...
};

class World {
public:
    World(){
        //initialize world's physics and geometry with default values
        setupWorld(defaultGravity, defaultSize, defaultBorderBehaviour);
    }
    ~World();

    hkpWorld*    getWorld() const { 
    //Yellow!!!
        //I'm Rajesh, I got Phd in India and now I'm going to fix one bug!
        
        hkpWorldCinfo worldInfo = new...;
        //let's change gravity from 9.8f to 10 because...
        worldInfo.m_gravity = 10;

        (const_cast<World*>(this))->physicsWorld =  new hkpWorld(worldInfo);
    return new hkpWorld(worldInfo); 
    };
    ...

private:
    ...
    hkpWorld *        physicsWorld;
    ...
};

Adaptive optimization is a technique in computer science that performs dynamic recompilation of portions of a program based on the current execution profile. With a simple implementation, an adaptive optimizer may simply make a trade-off between Just-in-time compilation and interpreting instructions. At another level, adaptive optimization may take advantage of local data conditions to optimize away branches and to use inline expansion.

A Virtual Machine like HotSpot is also able to deoptimize a previously JITed code. This allows it to perform aggressive (and potentially unsafe) optimizations, while still being able to deoptimize the code and fall back on a safe path later on.

JRockit does not include an interpreter; so the JIT compilation of the byte code into native machine code has to occur before a method executes. The JIT compilation is performed the first time a Java method is called.

public class WorldModel
{
  public double Gravity { get { return _gravity; } }
  private readonly double _gravity;

  public double RadiusKm { get { return _radiusKm; } } 
  private readonly double _radiusKm; 

  public double MassKg { get { return _massKg; } }
  private readonly double _massKg; 
  
  public WorldModel(double gravity, double radiusKm, double massKg)
  {
     _gravity = gravity;
     _radiusKm = radiusKm;
     _massKg = massKg;
  }

  public static readonly WorldModel EarthModel = new WorldModel(9.8, 6371, 5.972E24);
}

class Program
{
  static void Main(string[] args)
  {
    //Ooops compile time error.
    WorldModel.EarthModel.Gravity = 10.0; 
  }
}

M>Для чистоты экперимента — без нестандартных зависимостей, чтобы мне, не работавшему с плюсами много веков, не так сложно было собирать и запускать этот код

#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <numeric>

typedef std::complex<double> complex;
typedef std::vector<complex> chunk;

// вот начинается наша реализация векторной арифметики
chunk& operator*=(chunk& lhs, const chunk& rhs)
{
    for (size_t k = 0; k < lhs.size(); k++)
        lhs[k] *= rhs[k];
    return lhs;
}

chunk operator*(const chunk& lhs, const chunk& rhs)
{
    chunk res(lhs);
    return res *= rhs;
}
// а вот она закончилась.

int main()
{
    std::cout << std::fixed << std::setprecision(1);

    auto i = complex(0., 1.); // определили корень из минус единицы

    auto const s = 40000;
    auto data = std::vector<complex>(s, i); // создали массив размером в s элементов из i

    auto data2 = data * data; // возвели его в квадрат при помощи только что навелосипеженного оператора умножения

    auto sum = std::accumulate(data2.begin(), data2.end(), complex(0.)); // посчитали сумму массива
    std::cout << "sum(data2[]) = " << sum << '\n'; // чтобы проверить, что она равна -s.
    

}

data3_as_doubles[2*i] = data1_as_doubles[2*i]*data2_as_doubles[2*i]-data1_as_doubles[2*i+1]*data2_as_doubles[2*i+1];
data3_as_doubles[2*i+1] = data1_as_doubles[2*i]*data2_as_doubles[2*i+1]+data1_as_doubles[2*i+1]*data2_as_doubles[2*i];

S>data3_as_doubles[2*i] = data1_as_doubles[2*i]*data2_as_doubles[2*i]-data1_as_doubles[2*i+1]*data2_as_doubles[2*i+1];
S>data3_as_doubles[2*i+1] = data1_as_doubles[2*i]*data2_as_doubles[2*i+1]+data1_as_doubles[2*i+1]*data2_as_doubles[2*i];
S>

Vector result = v1 * v2 * v3 * v4;

M>>Для чистоты экперимента — без нестандартных зависимостей, чтобы мне, не работавшему с плюсами много веков, не так сложно было собирать и запускать этот код

EP>Пока ты редактировал сообщение, я уже сделал в таком виде Убрать зависимость boost конечно не сложно, но давай уже сделаем это после того как увидим Java версию.

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Thread)
@Fork(1)
@Warmup(iterations = 10)
@Measurement(iterations = 10)
@BenchmarkMode(Mode.AverageTime)
public class ComplexTest2 {

    private static class ComplexFlyweight
    {
        private final double[] ar;

        public ComplexFlyweight(double[] ar) {
            this.ar = ar;
        }

        public double re( int i )
        {
            return ar[ i *2 ];
        }

        public double im( int i )
        {
            return ar[ i * 2 + 1 ];
        }

        public void re( int i, double v )
        {
            ar[i * 2] = v;
        }

        public void im( int i, double v )
        {
            ar[i * 2+1] = v;
        }
    }

    private static final int N = 1 << 24;

    private double[] u_ar = new double[ N * 2 ];
    private double[] v_ar = new double[ N * 2 ];
    private ComplexFlyweight u = new ComplexFlyweight( u_ar );
    private ComplexFlyweight v = new ComplexFlyweight( v_ar );

    @Setup
    public void setup()
    {
        for ( int i = 0; i < v_ar.length; ++i ) {
            u_ar[i] = ThreadLocalRandom.current().nextInt( 32767 ) / 1000. - 1000.;
            v_ar[i] = ThreadLocalRandom.current().nextInt( 32767 ) / 1000. - 1000.;
        }
    }

    @Benchmark
    public double testVectorMult()
    {

        for ( int i = 0; i < u_ar.length / 2; ++i ) {
            v.re(i, u.re(i) * v.re(i) - u.im(i) * v.im(i) );
            v.im(i, u.re(i)*v.im(i) + u.im(i)*v.re(i));
        }
        return u.re( 0 );
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(".*" + ComplexTest2.class.getSimpleName() + ".*")
                .build();

        new Runner(opt).run();
    }
}

# Warmup: 10 iterations, 1 s each
# Measurement: 10 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: info.javaperformance.gccheck.ComplexTest2.testVectorMult

# Run progress: 0.00% complete, ETA 00:00:20
# Fork: 1 of 1
# Warmup Iteration   1: 60.429 ms/op
# Warmup Iteration   2: 58.038 ms/op
# Warmup Iteration   3: 58.117 ms/op
# Warmup Iteration   4: 57.762 ms/op
# Warmup Iteration   5: 57.733 ms/op
# Warmup Iteration   6: 57.863 ms/op
# Warmup Iteration   7: 57.885 ms/op
# Warmup Iteration   8: 57.698 ms/op
# Warmup Iteration   9: 57.609 ms/op
# Warmup Iteration  10: 57.925 ms/op
Iteration   1: 57.761 ms/op
Iteration   2: 57.685 ms/op
Iteration   3: 57.779 ms/op
Iteration   4: 57.570 ms/op
Iteration   5: 57.640 ms/op
Iteration   6: 57.743 ms/op
Iteration   7: 57.762 ms/op
Iteration   8: 57.696 ms/op
Iteration   9: 57.668 ms/op
Iteration  10: 57.756 ms/op


Result: 57.706 ±(99.9%) 0.101 ms/op [Average]
  Statistics: (min, avg, max) = (57.570, 57.706, 57.779), stdev = 0.067
  Confidence interval (99.9%): [57.605, 57.807]


# Run complete. Total time: 00:00:25

Benchmark                            Mode  Samples   Score  Score error  Units
i.j.g.ComplexTest2.testVectorMult    avgt       10  57.706        0.101  ms/op

main.cpp: In function 'Complex operator+(Complex, Complex)':
main.cpp:17:37: error: could not convert '{(x.Complex::re + y.Complex::re), (x.Complex::im + y.Complex::im)}' from '<brace-enclosed initializer list>' to 'Complex'
     return {x.re + y.re, x.im + y.im};

M>А вот тут ты немного обманываешься — ни в деке, ни в очереди ты уже безразрывный блок памяти не получишь, и весь твой выигрыш рискует превратиться в тыкву

EP>P.S. На Java можно писать быстрый код, но если выходить за рамки каких-то примитивнейших случаев (типа сортировки массива int'ов) — то приходится работать против языка, а не вместе с ним — нужно отказываться от GC и даже классов, и нарезать структуры вручную по массивам байт — по сути это уровень даже ниже чем в языке C.

M>            return ar[ i * 2 + 1 ];
M> ...
M>            ar[i * 2+1] = v;
M> ...
M>       private double[] u_ar = new double[ N * 2 ];
M> ...
M>        for ( int i = 0; i < u_ar.length / 2; ++i ) {
M>            v.re(i, u.re(i) * v.re(i) - u.im(i) * v.im(i) );
M>            v.im(i, u.re(i)*v.im(i) + u.im(i)*v.re(i));
M>        }

M>Просто поверь, что более сложную логику я точно также напишу (но за деньги ).

M>Кроме того, как я уже намекнул, твой пример скромно обходит любые выделения памяти

Complex(double re = 0., double im = 0.) : re(re), im(im) {}

M>>>А вот тут ты немного обманываешься — ни в деке, ни в очереди ты уже безразрывный блок памяти не получишь, и весь твой выигрыш рискует превратиться в тыкву

struct Foo
{
    int priority;
    vector<Bar> data;
};

M>>Попутно хотелось бы определить, по каким критериям мы сравниваем.
EP>Простоту работы со struct-like вещами, а конкретнее — скорость выполнения и удобство кода.

EP>P.S. На Java можно писать быстрый код, но если выходить за рамки каких-то примитивнейших случаев (типа сортировки массива int'ов) — то приходится работать против языка, а не вместе с ним — нужно отказываться от GC и даже классов, и нарезать структуры вручную по массивам байт — по сути это уровень даже ниже чем в языке C.

M>Ты мне так и не рассказал про кастомные аллокаторы, которыми славятся плюсы

M>50 против 57 мс (твой и мой примеры)? Именно из-за этого (если GC за скобки вынести). С заголовками у меня 180-190 мс было

M>Если сортировать объекты — само собой. Но ты ж не объекты сортировал? Таки зачем меня пытаешься убедить это делать?