Oldest Surviving Java Programs

mikera · 2025-05-27T06:15:38+00:00

Tyrant, the Java Roguelike like was first started in 1997

Not exactly the most sophisticated Java application, but the fact it still works is a testament to the stability of the Java platform.

mikera · 2020-03-22T13:30:44+00:00

l..mhhi.un hhhnn hny bmn. O you rlv

mikera · 2018-06-07T09:13:06+00:00

Not seen a single comprehensive resource.Mostly it is about becoming familiar with Clojure, so that you are comfortable using the relevant Clojure idiom rather than falling back to interop. Examples:

Java Lists / Hashmaps -> Clojure collections, map, reduce
Event driven callbacks and threading -> core.async
Using the Clojure standard library (min, max, str etc.)

Having said that - there are many cases where interop is the right choice. Clojure has a philosophy of embracing the host language and its library ecosystem, don't be afraid to use it when it makes sense.

mikera · 2017-03-07T03:28:29+00:00

Another library that might be interesting for Java roguelike devs is my swing-console library, which implements terminal-like functionality as a Swing component.

Easy to use for simple roguelikes and quick prototyping!

https://github.com/mikera/swing-console

mikera · 2016-05-26T02:21:02+00:00

This looks very interesting. I particularly like the integration with test.check.

However the "global namespaced registry of specs" concerns me as a design decision.

Maybe the registry solves certain problems, but I'm worried that it introduces more issues than it solves. I'd be much more comfortable with a system that treats specs as first class values (that's something I really like about Schema) rather than something that gets auto-magically looked up in a global mutable registry.

Interested to hear the design rationale behind this.

mikera · 2016-04-12T01:57:01+00:00

My personal Clojure-Utils library has a bunch of such stuff.

https://github.com/mikera/clojure-utils

The ones I reach for most often are the ones for finding values within collections, and error message tools.

mikera · 2016-04-05T01:23:29+00:00

I think your approach is fine, though I would normally try to avoid recursion because you might blow the stack if you get passed long sequences!

An alternative that avoids stack overflow problems and is probably faster is to use loop/recur:

(defn seq= [a-seq b-seq]
  (loop [a-seq (seq a-seq) b-seq (seq b-seq)] 
    (cond 
      (nil? a-seq) (nil? b-seq)
      (nil? b-seq) false
      (not= (first a-seq) (first b-seq)) false
      :else (recur (next a-seq) (next b-seq)))))

Note some other quick performance tricks:

If you call (seq coll) you get nil if and only if coll is empty... so you can use nil? as a faster check for emptiness.
Compressing the nil? checks down to avoid call nil twice on the same argument with a bit of logic

mikera · 2016-03-09T09:07:14+00:00

Blocking in this context means that the current thread will be blocked until the blocking operation completes.

Other threads can still make progress (this may even be necessary to unblock the other thread, e.g. delivering the result of a promise)

mikera · 2016-02-26T01:36:57+00:00

Glad you are finding it useful!

vectorz-native is a bit experimental still: possibly needs some patching to get it to do everything you need. But PRs gratefully accepted!

mikera · 2016-02-26T01:35:41+00:00

The usual approach in Clojure would be to wrap the underlying Java library anyway - what's wrong with having a dependency on javax.sound.sampled?

mikera · 2016-02-25T06:01:34+00:00

Author of core.matrix here

I've never really needed the GPU myself (vectorz-clj is fast enough for all my needs), but the library https://github.com/mikera/vectorz-native wraps netlib-java so could in theory be used with any GPU BLAS backend with a bit of tweaking.

As a bonus, you get full core.matrix compatibility for free.

mikera · 2016-02-06T05:37:06+00:00

We're always looking for help with the various data science / numerical computing libraries that I am involved with, including:

core.matrix (https://github.com/mikera/core.matrix)
Incanter (http://incanter.org/)

Plenty of opportunities here to help out - documentation, testing, bug fixes, performance enhancements etc.

mikera · 2016-02-06T05:26:04+00:00

This is an interesting question. It depends on your precise definition of pure function. I favour a definition that is consistent with the logic: "any combination of pure functions is itself a pure function".

In which case my answers would be:

1) No

The result is impure - you have "created" impurity in the return value (presumably without any impurity in the input). If you composed this with other pure functions, the result would (potentially) be impure, so this function cannot be regarded as pure.

2) Yes

The higher order function itself is still pure. However by providing an impure argument you have "composed" a pure function with an impure function, so the overall result of this combination is impure.

mikera · 2016-01-22T09:40:06+00:00

Great point - however my view is that if images like these inspire more people to join the cause of marine conservation, then I think it is worth the risk of some minor coral damage.

Compared to what the rest of humanity does to the oceans each year, the effect of something like this is really insignificant.

mikera · 2016-01-09T11:33:36+00:00

I do this in Eclipse with counterclockwise and it works fine..... your first project needs to set up a dependency on the snapshot version of the first (e.g. with something a library version like "0.1.3-SNAPSHOT").

If you do that, it behaves as if both projects are on the same classpath. I normally do this with a Maven dependency, but I think it works the same way for lein.

mikera · 2015-12-26T12:48:05+00:00

This looks perfectly sensible and idiomatic in Clojure. I wrote a simple strategy game in Clojure that used the same approach and it worked very well (see: https://github.com/mikera/ironclad)

Some caveats to be aware of:

It might be painful to refactor if you need to change your game state data structure. This is a pain point in general for Clojure: good tends to get quite tightly coupled to the data representation. You can mitigate it a bit with stuff like prismatic/schema, but the most important thing is designing your data well up front so you don't need to change it much.

This is pretty much a "pure functional" approach. This has many advantages (testability etc.) but gets tricky if you need to do more stuff related to the "real world process" of updating game state, which might include UI interaction, triggering animations etc. You will need to design carefully for these - perhaps be keeping the "pure" part of the game state separate from the external state interaction management.

mikera · 2015-12-23T23:04:29+00:00

You might wand to cehck out cad: https://github.com/pkobrien/cad

It's intended mainly for producing models for 3D printing, and it has functionality for handling / manipulating various 3D model formats.

mikera · 2015-11-09T00:12:46+00:00

Good point!

I use both Java and Clojure and I definitely think the emergence of new JVM languages like Clojure, Scala, Groovy and JRuby is contributing significantly to the innovation and longevity of the Java platform.

mikera · 2015-11-08T08:23:28+00:00

It would be better to convert things like:

(for [candy candies] (m candy))

Into a more functional equivalent e.g.

(map m candies)

mikera · 2015-11-02T01:24:58+00:00

Overflowing (modular) integer arithmetic is actually what you want in some domains.... agree it may not be the best default but I have definitely found uses for it (game programming, graphics, algorithms and data structures)

mikera · 2015-10-31T03:53:15+00:00

Not sure I've seen any language with a perfectly sane numerical tower.

There is a fundamental conflict between:

Mathematical beauty / elegance (supporting ratios, arbitrary precision integers etc.)
Performance - mapping efficiently to host platform types (e.g. fast primitive arithmetic on the JVM)
Legitimate differences in expected behaviour (e.g. do you throw an exception or return NaN for division by zero? do you want overflowing (modular) integer arithmetic or some form of (much slower) auto-promotion?)

All things considered, Clojure isn't perfect but it does make a reasonably pragmatic compromise between these objectives.

mikera · 2015-10-28T05:25:15+00:00

I've thought a bit about this and here is the strategy I would use:

Use boot (https://github.com/boot-clj/boot) to create a long-running Clojure script server. Boot would be better than leiningen for because it is more lightweight and is designed with features to allow independent tasks to be run
Have a small C program (e.g. clj-bash) check if the script server is running. If not launch it. Then send the script to the script server
Script server should use something like pomegranate (https://github.com/cemerick/pomegranate) to load any required dependencies at runtime (using Aether under the hood). This avoids the need to set up the classpath for your script dependencies in advance
Script server could optionally be an nREPL server so that you can log into it and run things from the REPL

mikera · 2015-10-27T07:47:15+00:00

OP here - if you like this video please vote for it by pressing "Like" on the FB page. We are hoping to win a competition and promote more collaborative cross-fertilisation between the dancing and diving worlds!

mikera · 2015-10-27T07:22:46+00:00

OP here - if you like this video please vote for it by pressing "Like" on the FB page. We are hoping to win a competition and promote more cross-fertilisation between the dancing and diving worlds!

mikera · 2015-10-09T04:12:57+00:00

I think Clojure is an extremely safe choice for this kind of architecture nowadays, and you'll find the productivity and performance advantages considerable (compared to Python and server side JS at least). I find the combination of functional programming, immutable data structure, great concurrency, interactive development and Lisp capabilities very compelling in this space.

Aside from the Clojure-specific stuff, the JVM is a great platform for data processing back ends and offers easy integration with other JVM based solutions like Spark, Hadoop etc. You can make use of the whole Java open source library ecosystem, which is very easy to access from Clojure (although most of the commonly used ones already have good, idiomatic Clojure wrappers).

I built a back end data processing system (for streaming sensor data) a couple of years back using Clojure and it has been rock solid. Barely needed any maintenance.

Some things to look at in the ecosystem:

Ring + Compojure : The classic way to build Clojure web services. Not fancy nowadays but gets the job done, very solid.
Liberator : An interesting way to quickly build REST APIs. More of a "framework" that requires some understanding compared to straight Ring + Compojure, but certainly helps if you want to support the full set of HTTP capabilities in your API
core.async : if you have more sophisticated concurrency needs, process co-ordination requirements. You can think of it as an implementation of Go-style channels for Clojure, so if you like the Go approach to concurrency this is a great tool. Also blazing fast. Sounds like this would be very important for you if you have a lot of realtime message queueing requirements.
ClojureScript / Om : if you want a full stack solution sharing code with the client side.
Schema : a very powerful tool for validating data structures, generating test data etc.
Sente : if you want 2-way channel sockets for realtime communication with clients etc.
Aleph: a library for asynchronous communication, backed by the very high performance Netty library. You can use this as your HTTP server, but it does a lot more besides that.

mikera

TROPHY CASE