NHacker Next
- new
- past
- show
- ask
- show
- jobs
- submit
login
Rendered at 18:44:49 GMT+0000 (Coordinated Universal Time) with Vercel.
Made an interactive map/index of the posts, linked by related topics. I made it to make the series easier to browse by concept instead of only by day number.
Toto.tech has a decent example. You have flight controls with wasd + mouse
Just use Apache Commons Lang Strings.CS.equalsAny . If not, List.of or Set.of (if N could be big) should be the best options. Streams are better when you chain many operations.
To name 2:
https://devdocs.io/openjdk~21/java.base/java/util/gregorianc...
https://devdocs.io/openjdk~21/java.base/java/net/url#equals(...
import java.util.ArrayList;
import java.util.List;
class Day06 {
public static void main(String args[]) {
List<String> fileTypeList = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
fileTypeList.add("fileType");
}
long beforeForLoop = System.currentTimeMillis();
for (int i = 0; i < fileTypeList.size(); i++) {
fileTypeList.get(i);
}
long afterForLoop = System.currentTimeMillis();
System.out.println("Time took in millis for for " + (afterForLoop - beforeForLoop));
long beforeForeachLoop = System.currentTimeMillis();
for (String s : fileTypeList) {
}
long afterForeachLoop = System.currentTimeMillis();
System.out.println("Time took in millis for foreach " + (afterForeachLoop - beforeForeachLoop));
}
}
If you want proper results you probably want to use the Java Microbenchmark Harness [0]. You'd probably want some actual data/work as well so the JIT doesn't overspecialize on the benchmark.
Edit: Halfheartedly tried to adapt the LinkedIn benchmark to JMH. Still not a great benchmark and I'm rusty so I wouldn't be surprised if I messed something up, but it's hopefully better the original:
package org.sample;
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.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MyBenchmark {
List<String> fileTypeList = new ArrayList<>() {{
for (int i = 0; i < 1000000; i++) {
this.add("fileType");
}
}};
@Benchmark
public void baseline() {
}
@Benchmark
public int measureFor() {
int result = 0;
for (int i = 0; i < fileTypeList.size(); i++) {
result += (int)fileTypeList.get(i).charAt(0);
}
return result;
}
@Benchmark
public int measureForEach() {
int result = 0;
for (String s : fileTypeList) {
result += (int)s.charAt(0);
}
return result;
}
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
.include(MyBenchmark.class.getSimpleName())
.build();
new Runner(opt).run();
}
}
# JMH version: 1.37
# VM version: JDK 21.0.10, OpenJDK 64-Bit Server VM, 21.0.10+7-Ubuntu-124.04
# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java
# VM options: <none>
# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable)
# Warmup: 5 iterations, 10 s each
# Measurement: 5 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
Result "org.sample.MyBenchmark.baseline":
0.254 ±(99.9%) 0.022 ns/op [Average]
(min, avg, max) = (0.247, 0.254, 0.262), stdev = 0.006
CI (99.9%): [0.232, 0.276] (assumes normal distribution)
Result "org.sample.MyBenchmark.measureFor":
693178.390 ±(99.9%) 60793.583 ns/op [Average]
(min, avg, max) = (676266.480, 693178.390, 718114.554), stdev = 15787.901
CI (99.9%): [632384.806, 753971.973] (assumes normal distribution)
Result "org.sample.MyBenchmark.measureForEach":
693756.240 ±(99.9%) 7549.769 ns/op [Average]
(min, avg, max) = (691685.231, 693756.240, 696573.323), stdev = 1960.651
CI (99.9%): [686206.470, 701306.009] (assumes normal distribution)
The biggest one is types -- students think in terms of meaning, not types, e.g. "this my variable contains first name", but they don't realize it's a string. Or "this is products in checkout cart", but the variable is an integer, so it's products count, not a list of product. Once students get idea of getting an item of a collection and getting a field of that item, while watching every type along the way -- that's a major breakthrough during learning.
The easiest to learn would be a language where you have to define all variable types on top, like Pascal (a language created specifically for learning). But Java is still better than Python, as it doesn't even run wit messed types.
Modern Java can be OOP, functional or procedural where useful. GoF patterns were never enforced by the language.
Or maybe that's even a bit rude to GoF. Some OO patterns - pretty questionable ones - were pushed pretty hard especially in Java EE.
Even then, you were never forced to use Java EE if you didn't need it.
Fwiw, I like that class names and file names must match. In python codebases I have had annoyances with this when I adopted others work.
As far as Java use in companies is an indicator, the horse is still running.
Javas biggest engineering upside was that its JIT compiler allowed the runtime to see through this mess and extract decent performance out of 5 layers of dynamic dispatch that shouldn't have been there in the first place.
Add to that the unclear licensing, which meant that there wasn't a single Linux distro that shipped it out of the box, and the development culture it fostered which required 10x the people each spending 10x the time to build features, and single-handedly was responsible for coining the term 'code monkey'.
As for the software - remember Eclipse? I sure do, but I haven't seen it in like half a decade or more, and that certainly doesnt make me sad.