# ADR-0002 - Avoid using Java serialization

## Date

2012-12-01

## Context

In Gradle we often need to serialize in-memory objects for caching, or to transmit them across process barriers, etc.
Java serialization is one way to implement this, however, despite its simplicity of implementation, it has several drawbacks:

- **Performance:**
Java's built-in serialization mechanism is often slower compared to other serialization solutions.

apiVersion: release-notes/v2
kind: bug-fix
area: istioctl
issue:
  - 44002
releaseNotes:
  - |
    **Fixed** `istioctl experimental revision describe` warning gateway is not enabled when gateway exists.
  - |

apiVersion: release-notes/v2
kind: feature
area: telemetry
issue:
  - 40027

releaseNotes:
  - |

    return PlainTextResponse("x" * 4000, status_code=200)


client = TestClient(app)


def test_middleware():
    response = client.get("/large", headers={"accept-encoding": "gzip"})
    assert response.status_code == 200, response.text
    assert response.text == "x" * 4000
    assert response.headers["Content-Encoding"] == "gzip"
    assert int(response.headers["Content-Length"]) < 4000
    response = client.get("/")

//
// System calls and other sys.stuff for mips, Linux
//

#include "go_asm.h"
#include "go_tls.h"
#include "textflag.h"

#define SYS_exit		4001
#define SYS_read		4003
#define SYS_write		4004
#define SYS_open		4005
#define SYS_close		4006
#define SYS_getpid		4020
#define SYS_kill		4037
#define SYS_brk			4045
#define SYS_mmap		4090
#define SYS_munmap		4091
#define SYS_setitimer		4104
#define SYS_clone		4120

        intervalControlHelper.addIntervalRule("22:15", "2:45", "1", 3000);
        assertEquals(0, intervalControlHelper.getDelay());

        intervalControlHelper.addIntervalRule("22:15", "2:45", "2", 4000);
        assertEquals(4000, intervalControlHelper.getDelay());
    }

    public void test_1215() throws ParseException {
        final IntervalControlHelper intervalControlHelper = createHelper("12:15", 1);

// ------------------------------------
// CHECK: Tensor 0 pconst kTfLiteInt32 kTfLiteMmapRo 4 / 0.00 (null) [{{.*}})
// CHECK-NEXT: Tensor 1 N kTfLiteInt32 kTfLiteMmapRo 4 / 0.00 (null) [{{.*}})
// CHECK-NEXT: Tensor 2 val kTfLiteFloat32 kTfLiteMmapRo 4 / 0.00 [1] [{{.*}})
// CHECK-NEXT: Tensor 3 tfl.while kTfLiteInt32 kTfLiteArenaRw 4 / 0.00 (null) [{{.*}})
// CHECK-NEXT: Tensor 4 result kTfLiteFloat32 kTfLiteArenaRw 4 / 0.00 [1] [{{.*}})

KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!-- START SNIPPET: superpom -->
<project>
  <modelVersion>4.0.0</modelVersion>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  </properties>

  <build>

		{serviceNamespace: "andromeda", expectError: true},
		// scenario 1: a service name along with a namespace and different port resolves
		{serviceName: "ross", serviceNamespace: "andromeda", port: 1002, expectedOutput: "https://ross.andromeda.svc:1002"},
	}

	// act
	for index, scenario := range scenarios {
		t.Run(fmt.Sprintf("scenario %d", index), func(t *testing.T) {
			target := defaultServiceResolver{}

+1.000000e+000 +2.000000e+000 +3.000000e+000 +4.000000e+000...