A new build of CSView is available, and it now supports Apple Silicon Macs (i.e. M1 series of SoCs which use the ARM aarch64 architecture)
The new version is 1.3.6 and is available to download
Due to Java’s support for Apple Silicon, it’s not possible to build an app bundle which supports both Apple and Intel CPUs at present. This is a requirement for distributing the app through the App Store, so for now I am only able to distribute the Intel build of CSView there.
CSView 2.0 Alpha 1 for MacOS is now available for download!
Download CSView 2.0 Alpha 1 - macOS 10.12+, 64-bit Intel, 3.5MB
Version 2.0 is a macOS native application, bringing performance and visual improvements.
Alpha 1 doesn’t yet support all the features of the 1.x releases, such as search and custom column delimiters. These will be coming in future alphas before the official 2.0 release.
I have a prototype grid renderer in the works for Windows too, but I’m focusing on getting a fully working Mac release ready first.
With the release of macOS Catalina (10.15) there have been some changes to the way software needs to be signed. In particular, Apple has introduced a new Notarization service which allows developers to pre-register the digital signature of an application so that it can be later checked by the operating system when a user downloads software outside the App Store.
I took this as a good opportunity to update to Java 11, and the rest of this article covers the changes I’ve needed to make to the packaging process.
Having seen Peter Bourgon’s post on multipart http responses come up in the Golang Weekly newsletter, I thought I would write some notes on a related problem I was looking at recently: how to stream a multipart upload to a remote HTTP server.
My specific use case is to receive a stream from AWS S3, and pipe it into the upload API for Asana. It’s probably ending up back in S3, but that’s neither here nor there.
The multipart writer provided with Go’s standard library makes serving multipart responses really easy, but sending an
HTTP request needs an io.Reader to provide a streaming request body, which doesn’t fit nicely with the
I found a couple of answers solving this problem, either by manually encoding the multipart headers or by running a separate goroutine to write into a pipe which can then be read by the HTTP client.
I settled on something in between: writing the headers to a byte buffer, then slicing the buffer and composing
io.MultiReader from the parts and the body reader from the S3
CompactList implements the
List<Long> interface, but internally it uses a tree of variable word-width segments to
improve performance and memory usage compared to an
Performance tends to be worse for appends than an
ArrayList but better for inserts. Memory usage is significantly
reduced, even for incompressible random data where it approaches the memory use of an array of primitive longs (which
happens to be the internal representation in this case).
While playing about with ideas for generic types in Go, I have come up with what I’m calling a ‘Generic Adapter’.
The approach I’ve taken here is essentialy that described by Kevin Gillette in a 2013 Post to golang-nuts. It implements ‘erasure-style’ generics by wrapping the generic implementation of each method with an adapter function which handles type assertions for the caller.
After my earlier experiments with B2, I had an extremely interesting call with Backblaze about B2 features and performance.
Firstly, they have recently added a caching layer to speed up serving repeatedly requested files. This reduces the delay as the file is reassembled from Reed-Solomon slices. They also suggested that I do some new tests, as they thought I should be seeing faster speeds, even for first-access.
I’ve been implementing a Go client library for the Backblaze B2 cloud storage service: go-backblaze. It works extremely well, but is a bit slow to get files back.
Update 12th December: I’ve spoken to Backblaze, who have been working to improve performance. I have performed some new tests and written them up.
After reading this article about Magnetic Poetry I was taken by the idea that the fridge was no longer the central notice board of the home:
Our age-old impulses haven’t gone away—changes in technology have just encouraged us to take them elsewhere. “It used to be the fridge door was the center of the home,” Kapell says. “That’s where people would hang their kids’ art, leave notes for each other, put pictures, all that stuff.”
So, I thought I would create a digital magnetic notice board, replete with fridge poetry, postcards and photos. I’ve got a few loose ends to tie up, but I’m pretty happy with the proof of concept.
Languamatch was an experimental service for locating language exchange partners based on shared interests and skill levels.
I was faced recently with wanting to move Asana projects from one workspace to another. Unfortunately this isn’t a feature in the Asana interface (yet).
There’s a PHP script floating around GitHub which will copy tasks between projects. This requires you to do some manual checking of project IDs, and you need to create the target project in advance, so I’ve extended the script and written a front-end web interface for it.
I’ve been trying out a number of file sync clients recently, finding that many are trying to solve the same problem and meeting with varying success. Probably the best-known service in this category is Dropbox, but nearly every big cloud services company, and a multitude of startups which base their services on top of them, are providing a ‘cloud drive’ of some description.
SlimTweet tries to shorten a message by applying a set of rules. For example,
and will be replaced by
it is will be replaced by
Substitutions will be made one at a time until the message reaches a target length (140 characters by default).
If SlimTweet still can’t make the message fit, it will start tweaking the Unicode characters which make up your message, without changing its appearance too much. For example, the digraph
vi will be replaced by the roman numeral character
ⅵ. When rendered in a standard font, these substitutions are nearly inⅵsible.
I’ve been experimenting with the Plex Media Server, and decided to have a go at securing remote access to the ‘Web Client’ interface using SSL (by default it runs over an unencrypted HTTP connection).
This post is essentially a gathering of instructions from where I found them on the internet.
I’m a co-author on a paper which was presented at RTNS this year. Sadly I didn’t have time to attend the conference, but it’s nice to have been able to contribute!
Now that Spotify has discontinued the free account, and restricted me to an ‘open’ account with only 10 hours of music a month, I’ve ended up paying for an ‘unlimited’ account.
While I’m a little disappointed with this turn of events, it does mean I am now able to use the Linux client. It seems pretty decent so far, but I wanted to map some keys to do things like play/pause and next.
I was doing some reading a while back into lock-free algorithms for multi-threaded communication using buffers. The general idea is to use a circular buffer in shared memory to allow one process (or thread) to write data into a buffer so that another process can read it. The algorithm relies on atomic compare-and-swap instructions, which are part of the x86 instruction set and also present in several other architectures which have features designed to assist with concurrency.
I’ve released a new version of Javada today - just a maintenance fix, after an email request for a pre-compiled version. It’s available for download from:
Also note, the licence is now LGPL.
I’ve been experimenting with PolyORB at work, and the documentation, while fine for configuring and compiling your application, is sorely lacking on any help with implementing your CORBA servants.
Here I’ll attempt to provide some brief hints on how to do things that don’t seem to be described in the documentation. The PolyORB mailing list is a good place to find more information.
[Nov 2021]: The mailing list seems to have been defunct since around 2016
Graphviz is a widely used graph layout package developed by AT&T.
There exist several ways of using Graphviz from Java, but in most cases the Graphviz command line tools are called to parse files containing a graph definition and render a rasterised image of the graph.
This is unsatisfactory for many interactive applications, and a more direct interface to the layout algorithms is desirable. Java bindings generated using SWIG already exist as part of the Graphviz source code, however they are very low-level.
jGraphViz aims to build on these low-level bindings to provide a more flexible interface to the graph model and layout system. It also provides some basic support for rendering the resulting layouts using GEF , and packages the library as an OSGi plugin compatible with Eclipse and other OSGi containers.
This project is hosted at SourceForge.