Archive for July, 2020

Nova Ret 2020 Update #2

July 24, 2020

As of July 24 2020, there are more than 100 Nova Ret 2020 observations, most visual, with a handful of CCD submissions. Mine (visual) are shown in purple.

Most observers are from Brazil (10), then Bolivia and Australia (5 each), with one from Italy and South Africa.

The southerly declination of the target and comparison stars in Reticulum (almost -55o degrees) makes northern hemisphere observations difficult.

A linear fit shows an overall decline of around 0.17 magnitudes per day, but there’s a lot of spread in the data and novae are unpredictable.

Nova Ret 2020 Update

July 18, 2020

The sky was largely cloudy at 5:45 this morning but a short-lived clear patch permitted a quick observation. The nova’s magnitude was between the 4.6 and 5.0 comparison stars in Reticulum (X25537DR chart), so around magnitude 4.8.

The AAVSO alert notice was issued a couple of days ago.

In my last post, I included a Stellarium screenshot of the field around the nova and Reticulum. Here’s a couple more for better context:

An hour later, I took another quick shot of the dawn NE sky showing the Moon, Venus and cloud (0.6 sec, ISO 200, f 2.0, unprocessed):

Nova in Reticulum!

July 17, 2020

Rob McNaught at Siding Spring, Coonabarabran, NSW found a magnitude 5.3 object in the constellation Reticulum on July 15 2020.

MGAB-V207’s pre-brightening magnitude was 15.8 (Johnson V). Just before I wrote this, it was designated N Ret 2020 in VSX and the AAVSO International Database.

I observed the nova at around 5:30am this morning (July 17) in 7×50 binoculars. My estimate, based upon 4.95 and 5.45 visual magnitude comparison stars, was 5.2.

It may have been brighter but that was my best estimate, given the seeing quality at the time, and a lack of coffee. Having said that, I’m confident that it was reasonable.

At the time of my submission to AAVSO this morning, there were 6 observations, including mine. Andrew Pearce in WA submitted his second observation (brighter) soon after mine.

This is the first bright nova since 2018! So I’m a little bit excited.

To get familiar with the field, I started with Stellarium:

and this AAVSO finder chart, which needs to be rotated by about 45 degrees anti-clockwise to match the Stellarium view:

In general, the sky was lovely this morning. After estimating the nova’s brightness, when the dawn became evident, I took this quick shot of a conjunction of the crescent Moon, Venus, and Aldebaran (alpha Tauri) low in the NE sky (1/5 sec, ISO 200, f 2.0, unprocessed) with our recently pruned walnut tree (thanks Karen!) visible at upper right:

Between the nova, satellites passing through my binocular field while observing it and the stars of Reticulum, a stray meteor, the Luna-Venus-Aldebaran conjunction, Orion rising in the east, and the general beauty of the sky, it was an uplifting start to the day.

I was again reminded that there is a hidden sky, waiting for all to see.

Variable stars and novae in particular, always reinforce to me the dynamic, constantly changing universe of which we are a small part. In what often feels like a dystopian world, especially in 2020, I find it oddly comforting that the Universe just keeps doing its thing, irrespective of us. Astronomy is a great way to get some perspective.

A quarter century of Java

July 4, 2020

We are all natives now, and everybody else not immediately one of us is an exotic. What looked once to be a matter of finding out whether savages could distinguish fact from fancy now looks to be a matter of finding out how others, across the sea or down the corridor, organise their significative world. (Clifford Geertz)

The Java Programming Language turned 25 years old on May 23 2020.

I’ve been writing Java code for 24 years, since 1996.

When Java arrived on the scene, my languages of choice were C, C++ and Perl, but mostly the first and last.

For me, there were at first various BASIC dialects, with smatterings of assembly code. Then at university and just at the moment I thought I knew something about programming, I learned Pascal, C and Fortran.

Later, languages such as LISP, Prolog, ML, CLIPS, SQL, even COBOL (about which I really never could find anything to like) showed me different ways in which a computer could be programmed.

Programming paradigms and language translation (compilers, interpreters) have interested me since around 1989. I wrote the ACE BASIC compiler in C from 1991 to 1996.

I’ve since designed and implemented other programming languages, including LittleLisp for the Newton PDA, and others that were only ever experiments, most personal projects, one commercial. In recent times I’ve been developing a domain specific functional language called VeLa that I’ll write about some time.

From the start, Java made it possible to write cross-platform programs, with or without GUIs, with relative ease.

Its byte-code compilation model resonated with me after having written my first compiler for a subset of Pascal in 1989 that generated USCD p-codes.

In 2004, six years after Java was released, Java 5 brought generics, regular expressions and assertions. I had craved these, especially the first two, for years, since writing C++ and Perl code in the early to mid-90s.

Java’s history is something of a long strange trip: from set-top boxes to web applets, the desktop, enterprise frameworks, smart cards and other embedded devices, to Just In Time compilation and dynamic profiling, WebStart and security model criticisms, and from Sun Microsystems to Oracle.

C# learned from Java’s mistakes. Some of its proponents have not always seemed to me to be honest about acknowledging its heritage though.

Programming Languages are tools for thought, for human communication, and not merely a means by which to bend a machine to our will. As I’ve mentioned elsewhere, they can also determine what it is possible for us to think.

My working days are now dominated by R, Python, C++ and sometimes Fortran; and bash of course. R and Python are powerful and have a rich ecosystem of tools and libraries, but I’m no fan of dynamic typing which makes it easy to get started, yet leaves too much unsaid, too many possibilities for error. This problem only becomes worse as programs grow.

Rust, Julia, Go, Clojure, Swift are all contenders to the throne now too. Which of these will stand the test of time? Which will one day be considered to have legacy code bases, just like Java, C, C++, Fortran, COBOL? All of them, I would say.

Then there are those languages like Haskell that blaze trails but tend not to be dominant. Java and most of the current crop owe such languages a debt of gratitude as functional programming’s higher order functions, type inference, and immutability have come out of academia to take over the world.

Distinguishing fact from fancy, fashion from solid ground, making predictions about the future of the programming language landscape is no easy task.

The older I get, the more selective I become about what new languages and frameworks to learn and the more interested I am in as much static typing, type inference, and run-time efficiency as I can get my hands on.

Yet, after a quarter century, I still like to code in Java whenever I can. It has its own beauty. I don’t pay much attention to its detractors. Of course, that’s where it’s important to think about context. If I’m writing code for a tiny embedded system or want to squeeze the most out of a machine, I’m more likely to code in C or C++ than anything else. But if I want to build a big habitable castle in the sky, I’ll still choose Java when I can.