summaryrefslogtreecommitdiff
path: root/wiki/java
diff options
context:
space:
mode:
Diffstat (limited to 'wiki/java')
-rw-r--r--wiki/java/a-new-kind-of.md137
-rw-r--r--wiki/java/install/centos.md57
-rw-r--r--wiki/java/install/index.md11
-rw-r--r--wiki/java/install/ubuntu.md84
-rw-r--r--wiki/java/kwargs.md152
-rw-r--r--wiki/java/stop-using-class-dot-forname.md69
6 files changed, 0 insertions, 510 deletions
diff --git a/wiki/java/a-new-kind-of.md b/wiki/java/a-new-kind-of.md
deleted file mode 100644
index 6cc81e5..0000000
--- a/wiki/java/a-new-kind-of.md
+++ /dev/null
@@ -1,137 +0,0 @@
-# A New Kind of Java
-
-Java 8 is almost here. You can [play with the early access
-previews](http://jdk8.java.net/download.html) right now, and I think you
-should, even if you don't like Java very much. There's so much _potential_ in
-there.
-
-## The “One More Thing”
-
-The Java 8 release comes with a slew of notable library improvements: the new
-[`java.time`](http://openjdk.java.net/jeps/150) package, designed by the folks
-behind the extremely capable Joda time library; [reflective
-access](http://openjdk.java.net/jeps/118) to parameter names; [Unicode
-6.2](http://openjdk.java.net/jeps/133) support; numerous others. But all of
-these things are dwarfed by the “one last thing”:
-
-**Lambdas**.
-
-## Ok, So..?
-
-Here's the thing: all of the “modern” languages that see regular use - C#,
-Python, Ruby, the various Lisps including Clojure, and Javascript - have
-language features allowing easy creation and use of one-method values. In
-Python, that's any object with a `__call__` method (including function
-objects); in Ruby, it's blocks; in Javascript, it's `function() {}`s. These
-features allow _computation itself_ to be treated as a value and passed
-around, which in turn provides a very powerful and succinct mechanism for
-composing features.
-
-Java's had the “use” side down for a long time; interfaces like `Runnable` are
-a great example of ways to expose “function-like” or “procedure-like” types to
-the language without violating Java's bureaucratic attitude towards types and
-objects. However, the syntax for creating these one-method values has always
-been so verbose and awkward as to discourage their use. Consider, for example,
-a simple “task” for a thread pool:
-
- pool.execute(new Runnable() {
- @Override
- public void run() {
- System.out.println("Hello, world!");
- }
- });
-
-(Sure, it's a dumb example.)
-
-Even leaving out the optional-but-recommended `@Override` annotation, that's
-still five lines of code that only exist to describe to the compiler how to
-package up a block as an object. Yuck. For more sophisticated tasks, this sort
-of verbosity has lead to multi-role “event handler” interfaces, to amortize
-the syntactic cost across more blocks of code.
-
-With Java 8's lambda support, the same (dumb) example collapses to
-
- pool.execute(() -> System.out.println("Hello, world"));
-
-It's the same structure and is implemented very similarly by the compiler.
-However, it's got much greater informational density for programmers reading
-the code, and it's much more pleasant to write.
-
-If there's any justice, this will completely change how people design Java
-software.
-
-## Event-Driven Systems
-
-As an example, I knocked together a simple “event driven IO” system in an
-evening, loosely inspired by node.js. Here's the echo server I wrote as an
-example application, in its entirety:
-
- package com.example.onepointeight;
-
- import java.io.IOException;
-
- public class Echo {
- public static void main(String[] args) throws IOException {
- Reactor.run(reactor ->
- reactor.listen(3000, client ->
- reactor.read(client, data -> {
- data.flip();
- reactor.write(client, data);
- })
- )
- );
- }
- }
-
-It's got a bad case of Javascript “arrow” disease, but it demonstrates the
-expressive power of lambdas for callbacks. This is built on NIO, and runs in a
-single thread; as with any decent multiplexed-IO application, it starts to
-have capacity problems due to memory exhaustion well before it starts to
-struggle with the number of clients. Unlike Java 7 and earlier, though, the
-whole program is short enough to keep in your head without worrying about the
-details of how each callback is converted into an object and without having to
-define three or four extra one-method classes.
-
-## Contextual operations
-
-Sure, we all know you use `try/finally` (or, if you're up on your Java 7,
-`try()`) to clean things up. However, context isn't always as tidy as that:
-sometimes things need to happen while it's set up, and un-happen when it's
-being torn down. The folks behind JdbcTemplate already understood that, so you
-can already write SQL operations using a syntax similar to
-
- User user = connection.query(
- "SELECT login, group FROM users WHERE username = ?",
- username,
- rows -> rows.one(User::fromRow)
- );
-
-Terser **and** clearer than the corresponding try-with-resources version:
-
- try (PreparedStatement ps = connection.prepare("SELECT login, group FROM users WHERE username = ?")) {
- ps.setString(1, username);
- try (ResultSet rows = rs.execute()) {
- if (!rows.next())
- throw new NoResultFoundException();
- return User.fromRow(rows);
- }
- }
-
-## Domain-Specific Languages
-
-I haven't worked this one out, yet, but I think it's possible to use lambdas
-to implement conversational interfaces, similar in structure to “fluent”
-interfaces like
-[UriBuilder](http://docs.oracle.com/javaee/6/api/javax/ws/rs/core/UriBuilder.html).
-If I can work out the mechanics, I'll put together an example for this, but
-I'm half convinced something like
-
- URI googleIt = Uris.create(() -> {
- scheme("http");
- host("google.com");
- path("/");
- queryParam("q", "hello world");
- });
-
-is possible.
-
diff --git a/wiki/java/install/centos.md b/wiki/java/install/centos.md
deleted file mode 100644
index 51c83f6..0000000
--- a/wiki/java/install/centos.md
+++ /dev/null
@@ -1,57 +0,0 @@
-# Installing Java on CentOS
-
-Verified as of CentOS 5.8, Java 6. CentOS 6 users: fucking switch to Debian
-already. Is something wrong with you? Do you like being abused by your
-vendors?
-
-## From Package Management (Yum)
-
-OpenJDK is available via [EPEL](http://fedoraproject.org/wiki/EPEL/FAQ), from
-the Fedora project. Install EPEL before proceeding.
-
-You didn't install EPEL. Go install EPEL. [The directions are in the EPEL
-FAQ](http://fedoraproject.org/wiki/EPEL/FAQ#Using_EPEL).
-
-Now install the JDK:
-
- sudo yum install java-1.6.0-openjdk-devel
-
-Or just the runtime:
-
- sudo yum install java-1.6.0-openjdk
-
-The RPMs place the appropriate binaries in `/usr/bin`.
-
-Applications that can't autodetect the JDK may need `JAVA_HOME` set to
-`/usr/lib/jvm/java-openjdk`.
-
-## By Hand
-
-The [Java SE Development Kit
-7](http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html)
-tarballs can be installed by hand. Download the “Linux x64” `.tar.gz` version,
-then unpack it in `/opt`:
-
- cd /opt
- tar xzf ~/jdk-7u45-linux-x64.tar.gz
-
-This will create a directory named `/opt/jdk1.7.0_45` (actual version number
-may vary) containing a ready-to-use Java dev kit.
-
-You will need to add the JDK's `bin` directory to `PATH` if you want commands
-like `javac` and `java` to work without fully-qualifying the directory:
-
- cat > /etc/profile.d/oracle_jdk <<'ORACLE_JDK'
- PATH="${PATH}:/opt/jdk1.7.0_45/bin"
- export PATH
- ORACLE_JDK
-
-(This will not affect non-interactive use; setting PATH for non-interactive
-programs like build servers is beyond the scope of this document. Learn to use
-your OS.)
-
-Installation this way does _not_ interact with the alternatives system (but
-you can set that up by hand if you need to).
-
-For tools that cannot autodetect the JDK via `PATH`, you may need to set
-`JAVA_HOME` to `/opt/jdk1.7.0_45`.
diff --git a/wiki/java/install/index.md b/wiki/java/install/index.md
deleted file mode 100644
index 684f050..0000000
--- a/wiki/java/install/index.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# Installing Java …
-
-This document provided as a community service to
-[##java](irc://irc.freenode.org/##java). Provided as-is; pull requests
-welcome.
-
-1. [… on Ubuntu](ubuntu) (may also be applicable to Debian; needs verification
- from a Debian user)
-
-2. [… on CentOS](centos) (probably also applicable to RHEL; needs verification
- from a RHEL user)
diff --git a/wiki/java/install/ubuntu.md b/wiki/java/install/ubuntu.md
deleted file mode 100644
index 75d3478..0000000
--- a/wiki/java/install/ubuntu.md
+++ /dev/null
@@ -1,84 +0,0 @@
-# Installing Java on Ubuntu
-
-Accurate as of: Java 7, Ubuntu 12.04. The instructions below assume an amd64
-(64-bit) installation. If you're still using a 32-bit OS, work out the
-differences yourself.
-
-## Via Package Management (Apt)
-
-OpenJDK 7 is available via apt by default.
-
-To install the JDK:
-
- sudo aptitude update
- sudo aptitude install openjdk-7-jdk
-
-To install the JRE only (without the JDK):
-
- sudo aptitude update
- sudo aptitude install openjdk-7-jre
-
-To install the JRE without GUI support (appropriate for headless servers):
-
- sudo aptitude update
- sudo aptitude install openjdk-7-jre-headless
-
-(You can also use `apt-get` instead of `aptitude`.)
-
-These packages interact with [the `alternatives`
-system](http://manpages.ubuntu.com/manpages/hardy/man8/update-alternatives.8.html),
-and have [a dedicated `alternatives` manager
-script](http://manpages.ubuntu.com/manpages/hardy/man8/update-java-alternatives.8.html).
-The `alternatives` system affects `/usr/bin/java`, `/usr/bin/javac`, and
-browser plugins for applets and Java Web Start applications for browsers
-installed via package management. It also affects the symlinks under
-`/etc/alternatives` related to Java.
-
-To list Java versions available, with at least one Java version installed via
-Apt:
-
- update-java-alternatives --list
-
-To switch to `java-1.7.0-openjdk-amd64` for all Java invocations:
-
- update-java-alternatives --set java-1.7.0-openjdk-amd64
-
-The value should be taken from the first column of the `--list` output.
-
-### Tool support
-
-Most modern Java tools will pick up the installed JDK via `$PATH` and do not
-need the `JAVA_HOME` environment variable set explicitly. For applications old
-enough not to be able to detect the JDK, you can set `JAVA_HOME` to
-`/usr/lib/jvm/java-1.7.0-openjdk-amd64`.
-
-## By Hand
-
-The [Java SE Development Kit
-7](http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html)
-tarballs can be installed by hand. Download the “Linux x64” `.tar.gz` version,
-then unpack it in `/opt`:
-
- cd /opt
- tar xzf ~/jdk-7u45-linux-x64.tar.gz
-
-This will create a directory named `/opt/jdk1.7.0_45` (actual version number
-may vary) containing a ready-to-use Java dev kit.
-
-You will need to add the JDK's `bin` directory to `PATH` if you want commands
-like `javac` and `java` to work without fully-qualifying the directory:
-
- cat > /etc/profile.d/oracle_jdk <<'ORACLE_JDK'
- PATH="${PATH}:/opt/jdk1.7.0_45/bin"
- export PATH
- ORACLE_JDK
-
-(This will not affect non-interactive use; setting PATH for non-interactive
-programs like build servers is beyond the scope of this document. Learn to use
-your OS.)
-
-Installation this way does _not_ interact with the alternatives system (but
-you can set that up by hand if you need to).
-
-For tools that cannot autodetect the JDK via `PATH`, you may need to set
-`JAVA_HOME` to `/opt/jdk1.7.0_45`.
diff --git a/wiki/java/kwargs.md b/wiki/java/kwargs.md
deleted file mode 100644
index d745010..0000000
--- a/wiki/java/kwargs.md
+++ /dev/null
@@ -1,152 +0,0 @@
-# Keyword Arguments in Java
-
-## What
-
-Java arguments are traditionally passed by position:
-
- void foo(int x, int y, int z)
-
-matches the call
-
- foo(1, 2, 3)
-
-and assigns `1` to `x`, `2` to `y`, and `3` to `z` in the resulting
-activation. Keyword arguments assign values to formal parameters by matching
-the parameter's name, instead.
-
-## Why
-
-Fuck the builder pattern, okay? Patterns like
-
- Response r = Response
- .status(200)
- .entity(foo)
- .header("X-Plane", "Amazing")
- .build();
-
-(from JAX-RS) mean the creation and maintenance of an entire separate type
-just to handle arbitrary ordering and presence/absence of options. Ordering
-can be done using keywords; presence/absence can be done by providing one
-method for each legal combination of arguments (or by adding optional
-arguments to Java).
-
-The keyword-argument version would be something like
-
- Response r = new Response(
- .status = 200,
- .entity = foo,
- .headers = Arrays.asList(Header.of("X-Plane", "Amazing"))
- );
-
-and the `ResponseBuilder` class would not need to exist at all for this case.
-(There are others in JAX-RS that would still make `ResponseBuilder` mandatory,
-but the use case for it gets much smaller.)
-
-As an added bonus, the necessary class metadata to make this work would also
-allow reflective frameworks such as Spring to make sensible use of the
-parameter names:
-
- <bean class="com.example.Person">
- <constructor-arg name="name" value="Erica McKenzie" />
- </bean>
-
-## Other Languages
-
-Python, most recently:
-
- def foo(x, y, z):
- pass
-
- foo(z=3, x=1, y=2)
-
-Smalltalk (and ObjectiveC) use an interleaving convention that reads very much
-like keyword arguments:
-
- Point atX: 5 atY: 8
-
-## Challenges
-
-* Minimize changes to syntax.
- * Make keyword arguments unambiguous.
-* Minimize changes to bytecode spec.
-
-## Proposal
-
-Given a method definition
-
- void foo(int x, int y, int z)
-
-Allow calls written as
-
- foo(
- SOME-SYNTAX(x, EXPR),
- SOME-SYNTAX(y, EXPR),
- SOME-SYNTAX(z, EXPR)
- )
-
-`SOME-SYNTAX` is a production that is not already legal at that point in Java,
-which is a surprisingly frustrating limitation. Constructs like
-
- foo(x = EXPR, y = EXPR, z = EXPR)
-
-are already legal (assignment is an expression) and already match positional
-arguments.
-
-Keyword arguments match the name of the formal argument in the method
-declaration. Passing a keyword argument that does not match a formal argument
-is a compilation error.
-
-Calls can mix keyword arguments and positional arguments, in the following
-order:
-
-1. Positional arguments.
-2. Varargs positional arguments.
-3. Keyword arguments.
-
-Passing the same argument as both a positional and a keyword argument is a
-compilation error.
-
-Call sites must satisfy every argument the method/constructor has (i.e., this
-doesn't imply optional arguments). This makes implementation easy and
-unintrusive: the compiler can implement keyword arguments by transforming them
-into positional arguments. Reflective calls (`Method.invoke` and friends) can
-continue accepting arguments as a sequence.
-
-The `Method` class would expose a new method:
-
- public List<String> getArgumentNames()
-
-The indexes in `getArgumentNames` match the indexes in `getArgumentTypes` and
-related methods.
-
-Possibilities for syntax:
-
-* `foo(x := 5, y := 8, z := 2)` - `:=` is never a legal sequence of tokens in
- Java. Introduces one new operator-like construct; the new sequence `:=`
- “looks like” assignment, which is a useful mnemonic.
-
-* `foo(x ~ 5, y ~ 8, z ~ 2)` - `~` is not a binary operator and this is never
- legal right now. This avoids introducing new operators, but adds a novel
- interpretation to an existing unary operator that's not related to its
- normal use.
-
-* `foo(.x = 5, .y = 8, .z = 2)` - using `=` as the keyword binding feels more
- natural. Parameter names must be legal identifiers, which means the leading
- dot is unambiguous. This syntax is not legal anywhere right now (the dot
- always has a leading expression). The dot is a “namespace” symbol already.
-
-To support this, the class file format will need to record the names of
-parameters, not just their order. This is a breaking change, and generated
-names will need to be chosen for existing class files. (This may be derivable
-from debug information, where present.)
-
-
-## Edge Cases
-
-* Mixed positional and keyword arguments.
- * Collisions (same argument passed by both) are, I think, detectable at
- compile time. This should be an error.
-* Inheritance. It is legal for a superclass to define `foo(a, b)` and for
- subclasses to override it as `foo(x, y)`. Which argument names do you use
- when?
-* Varargs.
diff --git a/wiki/java/stop-using-class-dot-forname.md b/wiki/java/stop-using-class-dot-forname.md
deleted file mode 100644
index b01e972..0000000
--- a/wiki/java/stop-using-class-dot-forname.md
+++ /dev/null
@@ -1,69 +0,0 @@
-# JDBC Drivers and `Class.forName()`
-
-The short version: stop using `Class.forName(driverClass)` to load JDBC
-drivers. You don't need this, and haven't since Java 6. You arguably never
-needed this.
-
-This pattern appears all over the internet, and it's wrong.
-
-## Backstory
-
-JDBC has more or less always provided two ways to set up `Connection` objects:
-
-1. Obtain them from a driver-provided `DataSource` class, which applications or
- containers are expected to create for themselves.
-
-2. Obtain them by passing a URL to `DriverManager`.
-
-Most people start with the latter, since it's very straightforward to use.
-However, `DriverManager` needs to be able to locate `Driver` subclasses, and
-the JVM doesn't permit class enumeration at runtime.
-
-In the original JDBC release, `Driver` subclasses were expected to register
-themselves on load, similar to
-
- public class ExampleDriver extends Driver {
- static {
- DriverManager.registerDriver(ExampleDriver.class);
- }
- }
-
-Obviously, applications _can_ force drivers to load using
-`Class.forName(driverName)`, but this hasn't ever been the only way to do it.
-`DriverManager` also provides [a mechanism to load a set of named classes at
-startup](https://docs.oracle.com/javase/8/docs/api/java/sql/DriverManager.html),
-via the `jdbc.drivers` [system property](http://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html).
-
-## JDBC 4 Fixed That
-
-JDBC 4, which came out with Java 6 in the Year of our Lord _Two Thousand and
-Six_, also loads drivers using the [service
-provider](https://docs.oracle.com/javase/8/docs/technotes/guides/jar/jar.html#Service%20Provider)
-system, which requires no intervention at all from deployers or application
-developers.
-
-_You don't need to write any code to load a JDBC 4 driver._
-
-## What's The Harm?
-
-It's harmless in the immediate sense: forcing a driver to load immediately
-before JDBC would load it itself has no additional side effects. However, it's
-a pretty clear indicator that you've copied someone else's code without
-thoroughly understanding what it does, which is a bad habit.
-
-## But What About My Database?
-
-You don't need to worry about it. All of the following drivers support JDBC
-4-style automatic discovery:
-
-* PostgreSQL (since version 8.0-321, in 2007)
-
-* Firebird (since [version 2.2, in 2009](http://tracker.firebirdsql.org/browse/JDBC-140))
-
-* [MySQL](../mysql/choose-something-else) (since [version 5.0, in 2005](http://dev.mysql.com/doc/relnotes/connector-j/en/news-5-0-0.html))
-
-* H2 (since day 1, as far as I can tell)
-
-* Derby/JavaDB (since [version 10.2.1.6, in 2006](https://issues.apache.org/jira/browse/DERBY-930))
-
-* SQL Server (version unknown, because MSDN is archaeologically hostile)
generated by cgit v1.2.3 (git 2.39.1) at 2026-01-02 16:45:19 +0000